diff --git a/src/EnergyPlus/AirLoopHVACDOAS.cc b/src/EnergyPlus/AirLoopHVACDOAS.cc
index 0d90a76534a..2fc92523f70 100644
--- a/src/EnergyPlus/AirLoopHVACDOAS.cc
+++ b/src/EnergyPlus/AirLoopHVACDOAS.cc
@@ -559,79 +559,109 @@ namespace AirLoopHVACDOAS {
                         FanOrder = CompNum;
                         break;
 
-                    case ValidEquipListType::CoilCoolingWater:
-                        thisOutsideAirSys.InletNodeNum(CompNum) = WaterCoils::GetCoilInletNode(state, typeNameUC, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) = WaterCoils::GetCoilOutletNode(state, typeNameUC, CompName, OutletNodeErrFlag);
-                        thisDOAS.CWCtrlNodeNum = WaterCoils::GetCoilWaterInletNode(state, "COIL:COOLING:WATER", CompName, errorsFound);
-                        if (errorsFound) {
-                            ShowContinueError(state, format("The control node number is not found in {} = {}", CurrentModuleObject, CompName));
-                        }
-                        PlantUtilities::ScanPlantLoopsForObject(
-                            state, CompName, DataPlant::PlantEquipmentType::CoilWaterCooling, thisDOAS.CWPlantLoc, errorsFound, _, _, _, _, _);
-                        if (errorsFound) { // is this really needed here, program fatals out later on when errorsFound = true
-                            ShowFatalError(state, "GetAirLoopDOASInput: Program terminated for previous conditions.");
+                    case ValidEquipListType::CoilCoolingWater: {
+                        int coilNum = WaterCoils::GetCoilIndex(state, CompName);
+                        if (coilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, "CompName", CompName);
+                            InletNodeErrFlag = OutletNodeErrFlag = true;
+                            errorsFound = true;
+                        } else {
+                            thisOutsideAirSys.InletNodeNum(CompNum) = WaterCoils::GetCoilAirInletNode(state, coilNum);
+                            thisOutsideAirSys.OutletNodeNum(CompNum) = WaterCoils::GetCoilAirOutletNode(state, coilNum);
+                            thisDOAS.CWCtrlNodeNum = WaterCoils::GetCoilWaterInletNode(state, coilNum);
+
+                            PlantUtilities::ScanPlantLoopsForObject(
+                                state, CompName, DataPlant::PlantEquipmentType::CoilWaterCooling, thisDOAS.CWPlantLoc, errorsFound, _, _, _, _, _);
+                            if (errorsFound) { // is this really needed here, program fatals out later on when errorsFound = true
+                              ShowFatalError(state, "GetAirLoopDOASInput: Program terminated for previous conditions.");
+                            }
                         }
                         CoolingCoilOrder = CompNum;
-                        break;
+                    } break;
 
-                    case ValidEquipListType::CoilHeatingWater:
-                        thisOutsideAirSys.InletNodeNum(CompNum) = WaterCoils::GetCoilInletNode(state, typeNameUC, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) = WaterCoils::GetCoilOutletNode(state, typeNameUC, CompName, OutletNodeErrFlag);
-                        thisDOAS.HWCtrlNodeNum = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", CompName, errorsFound);
-                        if (errorsFound) {
-                            ShowContinueError(state, format("The control node number is not found in {} = {}", CurrentModuleObject, CompName));
-                        }
-                        PlantUtilities::ScanPlantLoopsForObject(
-                            state, CompName, DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, thisDOAS.HWPlantLoc, errorsFound, _, _, _, _, _);
-                        if (errorsFound) { // is this really needed here, program fatals out later on when errorsFound = true
-                            ShowFatalError(state, "GetAirLoopDOASInput: Program terminated for previous conditions.");
+                    case ValidEquipListType::CoilHeatingWater: {
+                        int coilNum = WaterCoils::GetCoilIndex(state, CompName);
+                        if (coilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, "CompName", CompName);
+                            errorsFound = true;
+                            InletNodeErrFlag = OutletNodeErrFlag = true;
+                        } else {
+                            thisOutsideAirSys.InletNodeNum(CompNum) = WaterCoils::GetCoilAirInletNode(state, coilNum);
+                            thisOutsideAirSys.OutletNodeNum(CompNum) = WaterCoils::GetCoilAirOutletNode(state, coilNum);
+                            thisDOAS.HWCtrlNodeNum = WaterCoils::GetCoilWaterInletNode(state, coilNum);
+                            PlantUtilities::ScanPlantLoopsForObject(
+                                state, CompName, DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, thisDOAS.HWPlantLoc, errorsFound, _, _, _, _, _);
+                            if (errorsFound) { // is this really needed here, program fatals out later on when errorsFound = true
+                                ShowFatalError(state, "GetAirLoopDOASInput: Program terminated for previous conditions.");
+                            }
                         }
-                        break;
-
-                    case ValidEquipListType::CoilHeatingSteam:
-                        thisOutsideAirSys.InletNodeNum(CompNum) = SteamCoils::GetCoilSteamInletNode(state, CompType, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) = SteamCoils::GetCoilSteamOutletNode(state, CompType, CompName, OutletNodeErrFlag);
-                        break;
+                    } break;
 
-                    case ValidEquipListType::CoilCoolingWaterDetailedGeometry:
-                        thisOutsideAirSys.InletNodeNum(CompNum) = WaterCoils::GetCoilInletNode(state, typeNameUC, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) = WaterCoils::GetCoilOutletNode(state, typeNameUC, CompName, OutletNodeErrFlag);
-                        thisDOAS.CWCtrlNodeNum =
-                            WaterCoils::GetCoilWaterInletNode(state, "Coil:Cooling:Water:DetailedGeometry", CompName, errorsFound);
-                        if (errorsFound) {
-                            ShowContinueError(state, format("The control node number is not found in {} = {}", CurrentModuleObject, CompName));
+                    case ValidEquipListType::CoilHeatingSteam: {
+                        int coilNum = SteamCoils::GetCoilIndex(state, CompName);
+                        if (coilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, "CompName", CompName);
+                            InletNodeErrFlag = OutletNodeErrFlag = true;
+                            errorsFound = true;
+                        } else {
+                            // This was GetCoilSteamInletNode and GetCoilSteamOutlet node which I am pretty sure was a bug
+                            thisOutsideAirSys.InletNodeNum(CompNum) = SteamCoils::GetCoilAirInletNode(state, coilNum);
+                            thisOutsideAirSys.OutletNodeNum(CompNum) = SteamCoils::GetCoilAirOutletNode(state, coilNum);
                         }
-                        PlantUtilities::ScanPlantLoopsForObject(state,
-                                                                CompName,
-                                                                DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling,
-                                                                thisDOAS.CWPlantLoc,
-                                                                errorsFound,
-                                                                _,
-                                                                _,
-                                                                _,
-                                                                _,
-                                                                _);
-                        if (errorsFound) { // is this really needed here, program fatals out later on when errorsFound = true
-                            ShowFatalError(state, "GetAirLoopDOASInput: Program terminated for previous conditions.");
+                    } break;
+
+                    case ValidEquipListType::CoilCoolingWaterDetailedGeometry: {
+                        int coilNum = WaterCoils::GetCoilIndex(state, CompName);
+                        if (coilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, "CompName", CompName);
+                            InletNodeErrFlag = OutletNodeErrFlag = true;
+                            errorsFound = true;
+                        } else {
+                            thisOutsideAirSys.InletNodeNum(CompNum) = WaterCoils::GetCoilAirInletNode(state, coilNum);
+                            thisOutsideAirSys.OutletNodeNum(CompNum) = WaterCoils::GetCoilAirOutletNode(state, coilNum);
+                            thisDOAS.CWCtrlNodeNum = WaterCoils::GetCoilWaterInletNode(state, coilNum);
+                            PlantUtilities::ScanPlantLoopsForObject(state,
+                                                                    CompName,
+                                                                    DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling,
+                                                                    thisDOAS.CWPlantLoc,
+                                                                    errorsFound,
+                                                                    _,
+                                                                    _,
+                                                                    _,
+                                                                    _,
+                                                                    _);
+                            if (errorsFound) { // is this really needed here, program fatals out later on when errorsFound = true
+                                ShowFatalError(state, "GetAirLoopDOASInput: Program terminated for previous conditions.");
+                            }
                         }
                         CoolingCoilOrder = CompNum;
-                        break;
+                    } break;
 
                     case ValidEquipListType::CoilHeatingElectric:
-                    case ValidEquipListType::CoilHeatingFuel:
-                        thisOutsideAirSys.InletNodeNum(CompNum) = HeatingCoils::GetCoilInletNode(state, typeNameUC, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) = HeatingCoils::GetCoilOutletNode(state, typeNameUC, CompName, OutletNodeErrFlag);
-                        break;
+                    case ValidEquipListType::CoilHeatingFuel: {
+                        int coilNum = HeatingCoils::GetCoilIndex(state, CompName);
+                        if (coilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, "CompName", CompName);
+                            errorsFound = true;
+                        } else {
+                            thisOutsideAirSys.InletNodeNum(CompNum) = HeatingCoils::GetCoilAirInletNode(state, coilNum);
+                            thisOutsideAirSys.OutletNodeNum(CompNum) = HeatingCoils::GetCoilAirOutletNode(state, coilNum);
+                        }
+                    } break;
 
-                    case ValidEquipListType::CoilSystemCoolingWaterHeatExchangerAssisted:
-                        thisOutsideAirSys.InletNodeNum(CompNum) =
-                            HVACHXAssistedCoolingCoil::GetCoilInletNode(state, CompType, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) =
-                            HVACHXAssistedCoolingCoil::GetCoilOutletNode(state, CompType, CompName, OutletNodeErrFlag);
-                        break;
+                    case ValidEquipListType::CoilSystemCoolingWaterHeatExchangerAssisted: {
+                        int coilNum = HXAssistCoil::GetCoilIndex(state, CompName);
+                        if (coilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, "ComponentName", CompName);
+                            InletNodeErrFlag = OutletNodeErrFlag = true;
+                        } else {
+                            thisOutsideAirSys.InletNodeNum(CompNum) = HXAssistCoil::GetCoilAirInletNode(state, coilNum);
+                            thisOutsideAirSys.OutletNodeNum(CompNum) = HXAssistCoil::GetCoilAirOutletNode(state, coilNum);
+                        }
+                    } break;
 
                     case ValidEquipListType::CoilSystemCoolingDX:
-                    case ValidEquipListType::AirLoopHVACUnitarySystem:
+                    case ValidEquipListType::AirLoopHVACUnitarySystem: {
                         if (thisOutsideAirSys.compPointer[CompNum] == nullptr) {
                             UnitarySystems::UnitarySys thisSys;
                             thisOutsideAirSys.compPointer[CompNum] =
@@ -642,13 +672,18 @@ namespace AirLoopHVACDOAS {
                         thisOutsideAirSys.OutletNodeNum(CompNum) =
                             thisOutsideAirSys.compPointer[CompNum]->getAirOutNode(state, CompName, 0, OutletNodeErrFlag);
                         CoolingCoilOrder = CompNum;
-                        break;
+                    } break;
 
-                    case ValidEquipListType::CoilSystemHeatingDX:
-                        thisOutsideAirSys.InletNodeNum(CompNum) = HVACDXHeatPumpSystem::GetHeatingCoilInletNodeNum(state, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) =
-                            HVACDXHeatPumpSystem::GetHeatingCoilOutletNodeNum(state, CompName, OutletNodeErrFlag);
-                        break;
+                    case ValidEquipListType::CoilSystemHeatingDX: {
+                        int coilNum = HVACDXHeatPumpSystem::GetCoilIndex(state, CompName);
+                        if (coilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, "ComponentName", CompName);
+                            InletNodeErrFlag = OutletNodeErrFlag = true;
+                        } else {
+                           thisOutsideAirSys.InletNodeNum(CompNum) = HVACDXHeatPumpSystem::GetCoilAirInletNode(state, coilNum);
+                           thisOutsideAirSys.OutletNodeNum(CompNum) = HVACDXHeatPumpSystem::GetCoilAirOutletNode(state, coilNum);
+                        }
+                    } break;
 
                     case ValidEquipListType::CoilUserDefined:
                         ShowSevereError(state,
@@ -659,61 +694,68 @@ namespace AirLoopHVACDOAS {
 
                     case ValidEquipListType::HeatExchangerAirToAirFlatPlate:
                     case ValidEquipListType::HeatExchangerAirToAirSensibleAndLatent:
-                    case ValidEquipListType::HeatExchangerDesiccantBalancedFlow:
+                    case ValidEquipListType::HeatExchangerDesiccantBalancedFlow: {
                         thisOutsideAirSys.HeatExchangerFlag = true;
-                        thisOutsideAirSys.InletNodeNum(CompNum) = HeatRecovery::GetSupplyInletNode(state, CompName, InletNodeErrFlag);
-                        thisOutsideAirSys.OutletNodeNum(CompNum) = HeatRecovery::GetSupplyOutletNode(state, CompName, OutletNodeErrFlag);
-                        break;
+                        int hxNum = HeatRecovery::GetHeatExchangerIndex(state, CompName);
+                        if (hxNum == 0) {
+                            InletNodeErrFlag = OutletNodeErrFlag = true;
+                        } else { 
+                            thisOutsideAirSys.InletNodeNum(CompNum) = HeatRecovery::GetSupplyInletNode(state, hxNum);
+                            thisOutsideAirSys.OutletNodeNum(CompNum) = HeatRecovery::GetSupplyOutletNode(state, hxNum);
+                        }
+                    } break;
 
                     case ValidEquipListType::DehumidifierDesiccantNoFans:
-                    case ValidEquipListType::DehumidifierDesiccantSystem:
+                    case ValidEquipListType::DehumidifierDesiccantSystem: {
                         thisOutsideAirSys.InletNodeNum(CompNum) = DesiccantDehumidifiers::GetProcAirInletNodeNum(state, CompName, InletNodeErrFlag);
                         thisOutsideAirSys.OutletNodeNum(CompNum) =
                             DesiccantDehumidifiers::GetProcAirOutletNodeNum(state, CompName, OutletNodeErrFlag);
-                        break;
+                    } break;
 
                     case ValidEquipListType::HumidifierSteamElectric:
-                    case ValidEquipListType::HumidifierSteamGas:
+                    case ValidEquipListType::HumidifierSteamGas: {
                         thisOutsideAirSys.InletNodeNum(CompNum) = Humidifiers::GetAirInletNodeNum(state, CompName, InletNodeErrFlag);
                         thisOutsideAirSys.OutletNodeNum(CompNum) = Humidifiers::GetAirOutletNodeNum(state, CompName, OutletNodeErrFlag);
-                        break;
+                    } break;
 
-                    case ValidEquipListType::SolarCollectorUnglazedTranspired:
+                    case ValidEquipListType::SolarCollectorUnglazedTranspired: {
                         thisOutsideAirSys.InletNodeNum(CompNum) = TranspiredCollector::GetAirInletNodeNum(state, CompName, InletNodeErrFlag);
                         thisOutsideAirSys.OutletNodeNum(CompNum) = TranspiredCollector::GetAirOutletNodeNum(state, CompName, OutletNodeErrFlag);
-                        break;
+                    } break;
 
-                    case ValidEquipListType::SolarCollectorFlatPlatePhotovoltaicThermal:
+                    case ValidEquipListType::SolarCollectorFlatPlatePhotovoltaicThermal: {
                         thisOutsideAirSys.InletNodeNum(CompNum) =
                             PhotovoltaicThermalCollectors::GetAirInletNodeNum(state, CompName, InletNodeErrFlag);
                         thisOutsideAirSys.OutletNodeNum(CompNum) =
                             PhotovoltaicThermalCollectors::GetAirOutletNodeNum(state, CompName, OutletNodeErrFlag);
-                        break;
+                    } break;
 
                     case ValidEquipListType::EvaporativeCoolerDirectCeldekPad:
                     case ValidEquipListType::EvaporativeCoolerIndirectCeldekPad:
                     case ValidEquipListType::EvaporativeCoolerIndirectWetCoil:
                     case ValidEquipListType::EvaporativeCoolerIndirectResearchSpecial:
-                    case ValidEquipListType::EvaporativeCoolerDirectResearchSpecial:
+                    case ValidEquipListType::EvaporativeCoolerDirectResearchSpecial: {
                         thisOutsideAirSys.InletNodeNum(CompNum) = EvaporativeCoolers::GetInletNodeNum(state, CompName, InletNodeErrFlag);
                         thisOutsideAirSys.OutletNodeNum(CompNum) = EvaporativeCoolers::GetOutletNodeNum(state, CompName, OutletNodeErrFlag);
-                        break;
+                    } break;
 
-                    case ValidEquipListType::ZoneHVACTerminalUnitVariableRefrigerantFlow:
+                    case ValidEquipListType::ZoneHVACTerminalUnitVariableRefrigerantFlow: {
                         thisOutsideAirSys.InletNodeNum(CompNum) =
                             HVACVariableRefrigerantFlow::GetVRFTUInAirNodeFromName(state, CompName, InletNodeErrFlag);
                         thisOutsideAirSys.OutletNodeNum(CompNum) =
                             HVACVariableRefrigerantFlow::GetVRFTUOutAirNodeFromName(state, CompName, OutletNodeErrFlag);
-                        break;
+                    } break;
 
-                    default:
+                    default: {
                         ShowSevereError(state,
                                         format(R"({} = "{}" invalid Outside Air Component="{}".)",
                                                CurrentModuleObject,
                                                CompName,
                                                thisOutsideAirSys.ComponentType(CompNum)));
                         errorsFound = true;
-                    }
+                    } break;
+                    } // switch()
+                    
                     if (CoolingCoilOrder > FanOrder && !thisDOAS.FanBeforeCoolingCoilFlag) {
                         thisDOAS.FanBeforeCoolingCoilFlag = true;
                     }
@@ -882,13 +924,13 @@ namespace AirLoopHVACDOAS {
                 if (Util::SameString(CompType, "FAN:SYSTEMMODEL")) {
                     state.dataFans->fans(this->m_FanIndex)->simulate(state, FirstHVACIteration);
                 }
-                if (Util::SameString(CompType, "FAN:COMPONENTMODEL")) {
+                else if (Util::SameString(CompType, "FAN:COMPONENTMODEL")) {
                     state.dataFans->fans(this->m_FanIndex)->simulate(state, FirstHVACIteration);
                 }
 
-                if (Util::SameString(CompType, "COIL:HEATING:WATER")) {
+                else if (Util::SameString(CompType, "COIL:HEATING:WATER")) {
                     WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_HeatCoilNum);
-                    Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", CompName, ErrorsFound);
+                    Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_HeatCoilNum);
                     rho = state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
                     PlantUtilities::InitComponentNodes(state,
                                                        0.0,
@@ -896,20 +938,10 @@ namespace AirLoopHVACDOAS {
                                                        this->HWCtrlNodeNum,
                                                        state.dataAirLoop->OutsideAirSys(this->m_OASystemNum).OutletNodeNum(CompNum));
                 }
-                if (Util::SameString(CompType, "COIL:COOLING:WATER")) {
-                    WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum);
-                    Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water", CompName, ErrorsFound);
-                    rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName);
-                    PlantUtilities::InitComponentNodes(state,
-                                                       0.0,
-                                                       CoilMaxVolFlowRate * rho,
-                                                       this->CWCtrlNodeNum,
-                                                       state.dataAirLoop->OutsideAirSys(this->m_OASystemNum).OutletNodeNum(CompNum));
-                }
-                if (Util::SameString(CompType, "COIL:COOLING:WATER:DETAILEDGEOMETRY")) {
+                else if (Util::SameString(CompType, "COIL:COOLING:WATER") || 
+                         Util::SameString(CompType, "COIL:COOLING:WATER:DETAILEDGEOMETRY")) {
                     WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum);
-                    Real64 CoilMaxVolFlowRate =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water:DetailedGeometry", CompName, ErrorsFound);
+                    Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_CoolCoilNum);
                     rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName);
                     PlantUtilities::InitComponentNodes(state,
                                                        0.0,
diff --git a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp
index 4ab4e7b8b21..dfb30a04679 100644
--- a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp
+++ b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp
@@ -1513,7 +1513,7 @@ namespace AirflowNetwork {
                 DisSysCompHXData(i).EPlusType = hx_type;             // coil type
                 DisSysCompHXData(i).L = L;                           // Air path length
                 DisSysCompHXData(i).hydraulicDiameter = D;           // Air path hydraulic diameter
-                DisSysCompHXData(i).CoilParentExists = HVACHXAssistedCoolingCoil::VerifyHeatExchangerParent(m_state, hx_type, hx_name);
+                DisSysCompHXData(i).CoilParentExists = HXAssistCoil::VerifyHeatExchangerParent(m_state, hx_type, hx_name);
 
                 // Add the element to the lookup table, check for name overlaps
                 if (elements.find(DisSysCompHXData(i).name) == elements.end()) {
@@ -1623,7 +1623,7 @@ namespace AirflowNetwork {
         // Using/Aliasing
         using Curve::GetCurveIndex;
         using DataLoopNode::ObjectIsParent;
-        using HVACHXAssistedCoolingCoil::VerifyHeatExchangerParent;
+        using HXAssistCoil::VerifyHeatExchangerParent;
         using MixedAir::GetOAMixerNumber;
         using NodeInputManager::GetOnlySingleNode;
         using OutAirNodeManager::SetOutAirNodes;
@@ -10067,7 +10067,6 @@ namespace AirflowNetwork {
         using namespace DataLoopNode;
         auto &NumPrimaryAirSys = m_state.dataHVACGlobal->NumPrimaryAirSys;
         using DXCoils::SetDXCoilAirLoopNumber;
-        using HeatingCoils::SetHeatingCoilAirLoopNumber;
         using HVACStandAloneERV::GetStandAloneERVNodeNumber;
         using HVACVariableRefrigerantFlow::getVRFTUNodeNumber;
         using SplitterComponent::GetSplitterNodeNumbers;
@@ -10503,21 +10502,15 @@ namespace AirflowNetwork {
                         SetDXCoilAirLoopNumber(m_state, DisSysCompCoilData(i).name, DisSysCompCoilData(i).AirLoopNum);
                     }
 
-                } else if (SELECT_CASE_var == "COIL:HEATING:FUEL") {
-                    ValidateComponent(m_state, "Coil:Heating:Fuel", DisSysCompCoilData(i).name, IsNotOK, format(RoutineName) + CurrentModuleObject);
-                    if (IsNotOK) {
+                } else if (SELECT_CASE_var == "COIL:HEATING:FUEL" ||
+                           SELECT_CASE_var == "COIL:HEATING:ELECTRIC" ||
+                           SELECT_CASE_var == "COIL:HEATING:ELECTRIC:MULTISTAGE" ||
+                           SELECT_CASE_var == "COIL:HEATING:GAS:MULTISTAGE") {
+                    int coilNum = HeatingCoils::GetCoilIndex(m_state, DisSysCompCoilData(i).name);
+                    if (coilNum == 0) {
                         ErrorsFound = true;
                     } else {
-                        SetHeatingCoilAirLoopNumber(m_state, DisSysCompCoilData(i).name, DisSysCompCoilData(i).AirLoopNum, ErrorsFound);
-                    }
-
-                } else if (SELECT_CASE_var == "COIL:HEATING:ELECTRIC") {
-                    ValidateComponent(
-                        m_state, "Coil:Heating:Electric", DisSysCompCoilData(i).name, IsNotOK, format(RoutineName) + CurrentModuleObject);
-                    if (IsNotOK) {
-                        ErrorsFound = true;
-                    } else {
-                        SetHeatingCoilAirLoopNumber(m_state, DisSysCompCoilData(i).name, DisSysCompCoilData(i).AirLoopNum, ErrorsFound);
+                        HeatingCoils::SetCoilAirLoopNumber(m_state, coilNum, DisSysCompCoilData(i).AirLoopNum);
                     }
 
                 } else if (SELECT_CASE_var == "COIL:COOLING:WATER") {
@@ -10647,22 +10640,6 @@ namespace AirflowNetwork {
                     } else {
                         SetDXCoilAirLoopNumber(m_state, DisSysCompCoilData(i).name, DisSysCompCoilData(i).AirLoopNum);
                     }
-                } else if (SELECT_CASE_var == "COIL:HEATING:ELECTRIC:MULTISTAGE") {
-                    ValidateComponent(
-                        m_state, "Coil:Heating:Electric:MultiStage", DisSysCompCoilData(i).name, IsNotOK, format(RoutineName) + CurrentModuleObject);
-                    if (IsNotOK) {
-                        ErrorsFound = true;
-                    } else {
-                        SetHeatingCoilAirLoopNumber(m_state, DisSysCompCoilData(i).name, DisSysCompCoilData(i).AirLoopNum, ErrorsFound);
-                    }
-                } else if (SELECT_CASE_var == "COIL:HEATING:GAS:MULTISTAGE") {
-                    ValidateComponent(
-                        m_state, "Coil:Heating:Gas:MultiStage", DisSysCompCoilData(i).name, IsNotOK, format(RoutineName) + CurrentModuleObject);
-                    if (IsNotOK) {
-                        ErrorsFound = true;
-                    } else {
-                        SetHeatingCoilAirLoopNumber(m_state, DisSysCompCoilData(i).name, DisSysCompCoilData(i).AirLoopNum, ErrorsFound);
-                    }
                 } else {
                     ShowSevereError(m_state, format(RoutineName) + CurrentModuleObject + " Invalid coil type = " + DisSysCompCoilData(i).name);
                     ErrorsFound = true;
diff --git a/src/EnergyPlus/Autosizing/All_Simple_Sizing.cc b/src/EnergyPlus/Autosizing/All_Simple_Sizing.cc
index dc788ade567..460ea1e8bcb 100644
--- a/src/EnergyPlus/Autosizing/All_Simple_Sizing.cc
+++ b/src/EnergyPlus/Autosizing/All_Simple_Sizing.cc
@@ -313,8 +313,7 @@ Real64 HeatingCoilDesAirInletTempSizer::size(EnergyPlusData &state, Real64 _orig
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-            state, this->compName, this->compType, this->autoSizedValue, this->curSysNum, this->curZoneEqNum);
+        ReportCoilSelection::setCoilEntAirTemp(state, this->compName, this->coilType, this->autoSizedValue, this->curSysNum, this->curZoneEqNum);
     return this->autoSizedValue;
 }
 
@@ -346,7 +345,7 @@ Real64 HeatingCoilDesAirOutletTempSizer::size(EnergyPlusData &state, Real64 _ori
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, this->compName, this->compType, this->autoSizedValue);
+        ReportCoilSelection::setCoilLvgAirTemp(state, this->compName, this->coilType, this->autoSizedValue);
     return this->autoSizedValue;
 }
 
@@ -382,7 +381,7 @@ Real64 HeatingCoilDesAirInletHumRatSizer::size(EnergyPlusData &state, Real64 _or
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, this->compName, this->compType, this->autoSizedValue);
+        ReportCoilSelection::setCoilEntAirHumRat(state, this->compName, this->coilType, this->autoSizedValue);
     return this->autoSizedValue;
 }
 
diff --git a/src/EnergyPlus/Autosizing/Base.cc b/src/EnergyPlus/Autosizing/Base.cc
index 6fa956ffe0c..53a3fa715fb 100644
--- a/src/EnergyPlus/Autosizing/Base.cc
+++ b/src/EnergyPlus/Autosizing/Base.cc
@@ -66,6 +66,8 @@ void BaseSizer::initializeWithinEP(EnergyPlusData &state,
 {
     this->initialized = true;
     this->compType = _compType;
+    // This is done during the isValidCoilType call.  Why?
+    // this->coilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Util::makeUPPER(_compType)));
     this->compName = _compName;
     this->isEpJSON = state.dataGlobal->isEpJSON;
     this->printWarningFlag = _printWarningFlag;
@@ -571,16 +573,8 @@ void BaseSizer::select2StgDXHumCtrlSizerOutput(EnergyPlusData &state, bool &erro
 
 bool BaseSizer::isValidCoilType(std::string const &_compType)
 {
-    int coilNum = 0;
-    for (auto const &coilType : HVAC::cAllCoilTypes) {
-        coilNum += 1;
-        if (Util::SameString(_compType, coilType)) {
-            this->coilType_Num = coilNum;
-            return true;
-        }
-    }
-    this->coilType_Num = 0;
-    return false;
+    this->coilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Util::makeUPPER(_compType)));
+    return this->coilType != HVAC::CoilType::Invalid;
 }
 
 bool BaseSizer::isValidFanType(std::string const &_compType)
@@ -731,7 +725,7 @@ void BaseSizer::clearState()
     sizingDesValueFromParent = false;
     airLoopSysFlag = false;
     oaSysFlag = false;
-    coilType_Num = 0;
+    coilType = HVAC::CoilType::Invalid;
     compType = "";
     compName = "";
     isEpJSON = false;
diff --git a/src/EnergyPlus/Autosizing/Base.hh b/src/EnergyPlus/Autosizing/Base.hh
index 969d4945ee0..e84e28204cd 100644
--- a/src/EnergyPlus/Autosizing/Base.hh
+++ b/src/EnergyPlus/Autosizing/Base.hh
@@ -139,7 +139,7 @@ struct BaseSizer
     bool sizingDesValueFromParent = false;
     bool airLoopSysFlag = false;
     bool oaSysFlag = false;
-    int coilType_Num = 0;
+    HVAC::CoilType coilType = HVAC::CoilType::Invalid;
     std::string compType;
     std::string compName;
     bool isEpJSON = false;
diff --git a/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.cc b/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.cc
index aafda6804f5..d98fd67c41a 100644
--- a/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.cc
+++ b/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.cc
@@ -101,10 +101,10 @@ void BaseSizerWithScalableInputs::initializeWithinEP(EnergyPlusData &state,
 
         // This should work for both fan types
         if (this->primaryAirSystem(this->curSysNum).supFanNum > 0) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
+            ReportCoilSelection::setCoilSupplyFanInfo(
                 state,
                 this->compName,
-                this->compType,
+                this->coilType,
                 state.dataFans->fans(this->primaryAirSystem(this->curSysNum).supFanNum)->Name,
                 state.dataFans->fans(this->primaryAirSystem(this->curSysNum).supFanNum)->type,
                 this->primaryAirSystem(this->curSysNum).supFanNum);
diff --git a/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.hh b/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.hh
index 4b9a4a4425e..bad2cf14b63 100644
--- a/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.hh
+++ b/src/EnergyPlus/Autosizing/BaseSizerWithScalableInputs.hh
@@ -86,7 +86,7 @@ struct BaseSizerWithScalableInputs : BaseSizerWithFanHeatInputs
     Real64 suppHeatCap = 0.0;
     Real64 unitaryHeatCap = 0.0;
     int dataTotCapCurveIndex = 0;
-    int dataCoolCoilType = -1;
+    HVAC::CoilType dataCoolCoilType = HVAC::CoilType::Invalid; // Why the 'data' prefix?
     int dataCoolCoilIndex = -1;
 
     int zoneHVACSizingIndex = 0;
@@ -125,7 +125,7 @@ struct BaseSizerWithScalableInputs : BaseSizerWithFanHeatInputs
         suppHeatCap = 0.0;
         unitaryHeatCap = 0.0;
         zoneHVACSizingIndex = 0;
-        dataCoolCoilType = -1;
+        dataCoolCoilType = HVAC::CoilType::Invalid;
         dataCoolCoilIndex = -1;
         zoneHVACSizing.clear();
     }
diff --git a/src/EnergyPlus/Autosizing/CoolingAirFlowSizing.cc b/src/EnergyPlus/Autosizing/CoolingAirFlowSizing.cc
index fc9b825def6..13028475cef 100644
--- a/src/EnergyPlus/Autosizing/CoolingAirFlowSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingAirFlowSizing.cc
@@ -337,7 +337,7 @@ Real64 CoolingAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, b
             if (Util::SameString(this->compType, "ZoneHVAC:FourPipeFanCoil")) {
                 this->sizingString = "Maximum Supply Air Flow Rate [m3/s]";
                 if (this->isEpJSON) this->sizingString = "maximum_supply_air_flow_rate [m3/s]";
-            } else if (this->coilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+            } else if (this->coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 if (this->dataDXSpeedNum == 1) { // mode 1 is high speed in DXCoils loop
                     if (this->isEpJSON) {
                         this->sizingString = "high_speed_rated_air_flow_rate [m3/s]";
@@ -355,18 +355,18 @@ Real64 CoolingAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, b
                 this->sizingString = "cooling_supply_air_flow_rate [m3/s]";
             }
         }
-        if (this->dataScalableSizingON) {
-            if (this->zoneAirFlowSizMethod == DataSizing::SupplyAirFlowRate || this->zoneAirFlowSizMethod == DataSizing::None) {
-                this->sizingStringScalable = "(scaled by flow / zone) ";
-            } else if (this->zoneAirFlowSizMethod == DataSizing::FlowPerFloorArea) {
-                this->sizingStringScalable = "(scaled by flow / area) ";
-            } else if (this->zoneAirFlowSizMethod == DataSizing::FractionOfAutosizedCoolingAirflow ||
-                       this->zoneAirFlowSizMethod == DataSizing::FractionOfAutosizedHeatingAirflow) {
-                this->sizingStringScalable = "(scaled by fractional multiplier) ";
-            } else if (this->zoneAirFlowSizMethod == DataSizing::FlowPerCoolingCapacity ||
-                       this->zoneAirFlowSizMethod == DataSizing::FlowPerHeatingCapacity) {
-                this->sizingStringScalable = "(scaled by flow / capacity) ";
-            }
+    }
+    if (this->dataScalableSizingON) {
+        if (this->zoneAirFlowSizMethod == DataSizing::SupplyAirFlowRate || this->zoneAirFlowSizMethod == DataSizing::None) {
+            this->sizingStringScalable = "(scaled by flow / zone) ";
+        } else if (this->zoneAirFlowSizMethod == DataSizing::FlowPerFloorArea) {
+            this->sizingStringScalable = "(scaled by flow / area) ";
+        } else if (this->zoneAirFlowSizMethod == DataSizing::FractionOfAutosizedCoolingAirflow ||
+                   this->zoneAirFlowSizMethod == DataSizing::FractionOfAutosizedHeatingAirflow) {
+            this->sizingStringScalable = "(scaled by fractional multiplier) ";
+        } else if (this->zoneAirFlowSizMethod == DataSizing::FlowPerCoolingCapacity ||
+                   this->zoneAirFlowSizMethod == DataSizing::FlowPerHeatingCapacity) {
+            this->sizingStringScalable = "(scaled by flow / capacity) ";
         }
     }
     if (this->dataDXCoolsLowSpeedsAutozize) {
@@ -376,8 +376,7 @@ Real64 CoolingAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, b
 
     if (this->isCoilReportObject) {
         // SizingResult is airflow in m3/s
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
-            state, this->compName, this->compType, this->autoSizedValue, this->wasAutoSized);
+      ReportCoilSelection::setCoilAirFlow(state, this->compName, this->coilType, this->autoSizedValue, this->wasAutoSized);
     }
     if (this->isFanReportObject) {
         //  fill fan peak day and time here
@@ -394,8 +393,7 @@ Real64 CoolingAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, b
                     dateTimeFanPeak = format("{}/{} {}",
                                              state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                              state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                 state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                             ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                 }
             } else if (heatingFlow) {
                 if (this->finalZoneSizing(this->curZoneEqNum).HeatDDNum > 0 &&
@@ -404,8 +402,7 @@ Real64 CoolingAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, b
                     dateTimeFanPeak = format("{}/{} {}",
                                              state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                              state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                 state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                             ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                 }
             }
         }
diff --git a/src/EnergyPlus/Autosizing/CoolingCapacitySizing.cc b/src/EnergyPlus/Autosizing/CoolingCapacitySizing.cc
index ec2c01fcab4..47d92dc3d04 100644
--- a/src/EnergyPlus/Autosizing/CoolingCapacitySizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingCapacitySizing.cc
@@ -165,8 +165,8 @@ Real64 CoolingCapacitySizer::size(EnergyPlusData &state, Real64 _originalValue,
                             if (DDNum > 0 && TimeStepNumAtMax > 0) {
                                 OutTemp = state.dataSize->DesDayWeath(DDNum).Temp(TimeStepNumAtMax);
                             }
-                            if (this->dataCoolCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
-                                OutTemp = VariableSpeedCoils::GetVSCoilRatedSourceTemp(state, this->dataCoolCoilIndex);
+                            if (this->dataCoolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
+                                OutTemp = VariableSpeedCoils::GetCoilRatedSourceTemp(state, this->dataCoolCoilIndex);
                             }
                             Real64 CoilInEnth = Psychrometrics::PsyHFnTdbW(CoilInTemp, CoilInHumRat);
                             Real64 CoilOutEnth = Psychrometrics::PsyHFnTdbW(CoilOutTemp, CoilOutHumRat);
@@ -269,12 +269,11 @@ Real64 CoolingCapacitySizer::size(EnergyPlusData &state, Real64 _originalValue,
                     CoilOutHumRat = state.dataSize->DataCoilSizingAirOutHumRat;
                     FanCoolLoad = state.dataSize->DataCoilSizingFanCoolLoad;
                     TotCapTempModFac = state.dataSize->DataCoilSizingCapFT;
-                    if (state.dataRptCoilSelection->coilSelectionReportObj->isCompTypeCoil(this->compType)) {
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, this->compName, this->compType, CoilInHumRat);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                            state, this->compName, this->compType, CoilInTemp, this->curSysNum, this->curZoneEqNum);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, this->compName, this->compType, CoilOutTemp);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(state, this->compName, this->compType, CoilOutHumRat);
+                    if (ReportCoilSelection::isCompTypeCoil(this->compType)) {
+                        ReportCoilSelection::setCoilEntAirHumRat(state, this->compName, this->coilType, CoilInHumRat);
+                        ReportCoilSelection::setCoilEntAirTemp(state, this->compName, this->coilType, CoilInTemp, this->curSysNum, this->curZoneEqNum);
+                        ReportCoilSelection::setCoilLvgAirTemp(state, this->compName, this->coilType, CoilOutTemp);
+                        ReportCoilSelection::setCoilLvgAirHumRat(state, this->compName, this->coilType, CoilOutHumRat);
                     }
                 } else if (this->curOASysNum > 0 && this->outsideAirSys(this->curOASysNum).AirLoopDOASNum > -1) {
                     auto &thisAirloopDOAS = this->airloopDOAS[this->outsideAirSys(this->curOASysNum).AirLoopDOASNum];
@@ -376,8 +375,8 @@ Real64 CoolingCapacitySizer::size(EnergyPlusData &state, Real64 _originalValue,
                             if (this->dataDesInletAirHumRat > 0.0) CoilInHumRat = this->dataDesInletAirHumRat;
                         }
                         Real64 OutTemp = thisFinalSysSizing.OutTempAtCoolPeak;
-                        if (this->dataCoolCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
-                            OutTemp = VariableSpeedCoils::GetVSCoilRatedSourceTemp(state, this->dataCoolCoilIndex);
+                        if (this->dataCoolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
+                            OutTemp = VariableSpeedCoils::GetCoilRatedSourceTemp(state, this->dataCoolCoilIndex);
                         }
                         CoilOutTemp = min(CoilInTemp, CoilOutTemp);
                         CoilOutHumRat = min(CoilInHumRat, CoilOutHumRat);
@@ -551,26 +550,25 @@ Real64 CoolingCapacitySizer::size(EnergyPlusData &state, Real64 _originalValue,
 
     if (this->isCoilReportObject && this->curSysNum <= state.dataHVACGlobal->NumPrimaryAirSys) {
         if (CoilInTemp > -999.0) { // set inlet air properties used during capacity sizing if available, allow for negative winter temps
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                state, this->compName, this->compType, CoilInTemp, this->curSysNum, this->curZoneEqNum);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, this->compName, this->compType, CoilInHumRat);
+            ReportCoilSelection::setCoilEntAirTemp(state, this->compName, this->coilType, CoilInTemp, this->curSysNum, this->curZoneEqNum);
+            ReportCoilSelection::setCoilEntAirHumRat(state, this->compName, this->coilType, CoilInHumRat);
         }
         if (CoilOutTemp > -999.0) { // set outlet air properties used during capacity sizing if available
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, this->compName, this->compType, CoilOutTemp);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(state, this->compName, this->compType, CoilOutHumRat);
+            ReportCoilSelection::setCoilLvgAirTemp(state, this->compName, this->coilType, CoilOutTemp);
+            ReportCoilSelection::setCoilLvgAirHumRat(state, this->compName, this->coilType, CoilOutHumRat);
         }
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(state,
-                                                                                   this->compName,
-                                                                                   this->compType,
-                                                                                   this->autoSizedValue,
-                                                                                   this->wasAutoSized,
-                                                                                   this->curSysNum,
-                                                                                   this->curZoneEqNum,
-                                                                                   this->curOASysNum,
-                                                                                   FanCoolLoad,
-                                                                                   TotCapTempModFac,
-                                                                                   DXFlowPerCapMinRatio,
-                                                                                   DXFlowPerCapMaxRatio);
+        ReportCoilSelection::setCoilCoolingCapacity(state,
+                                                    this->compName,
+                                                    this->coilType,
+                                                    this->autoSizedValue,
+                                                    this->wasAutoSized,
+                                                    this->curSysNum,
+                                                    this->curZoneEqNum,
+                                                    this->curOASysNum,
+                                                    FanCoolLoad,
+                                                    TotCapTempModFac,
+                                                    DXFlowPerCapMinRatio,
+                                                    DXFlowPerCapMaxRatio);
     }
     return this->autoSizedValue;
 }
diff --git a/src/EnergyPlus/Autosizing/CoolingSHRSizing.cc b/src/EnergyPlus/Autosizing/CoolingSHRSizing.cc
index 393940ed423..7b25650e57e 100644
--- a/src/EnergyPlus/Autosizing/CoolingSHRSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingSHRSizing.cc
@@ -101,7 +101,7 @@ Real64 CoolingSHRSizer::size(EnergyPlusData &state, Real64 _originalValue, bool
 
                     // check that the autosized SHR corresponds to a valid apperatus dew point (ADP) temperature
                     this->autoSizedValue = DXCoils::ValidateADP(state,
-                                                                this->compType,
+                                                                this->coilType,
                                                                 this->compName,
                                                                 RatedInletAirTemp,
                                                                 RatedInletAirHumRat,
@@ -134,7 +134,7 @@ void CoolingSHRSizer::updateSizingString(EnergyPlusData &state)
 {
     if (!overrideSizeString) return;
     // override sizingString to match existing text
-    if (this->coilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+    if (this->coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
         if (this->dataDXSpeedNum == 1) { // mode 1 is high speed in DXCoils loop
             if (this->isEpJSON) {
                 this->sizingString = "high_speed_rated_sensible_heat_ratio";
@@ -148,19 +148,19 @@ void CoolingSHRSizer::updateSizingString(EnergyPlusData &state)
                 this->sizingString = "Low Speed Gross Rated Sensible Heat Ratio";
             }
         }
-    } else if (this->coilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+    } else if (this->coilType == HVAC::CoilType::CoolingDXMultiSpeed) {
         if (this->isEpJSON) {
             this->sizingString = fmt::format("speed_{}_rated_sensible_heat_ratio", state.dataSize->DataDXSpeedNum);
         } else {
             this->sizingString = fmt::format("Speed {} Rated Sensible Heat Ratio", state.dataSize->DataDXSpeedNum);
         }
-    } else if (this->coilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
+    } else if (this->coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
         if (this->isEpJSON) {
             this->sizingString = "rated_sensible_heat_ratio";
         } else {
             this->sizingString = "Rated Sensible Heat Ratio";
         }
-    } else if (this->coilType_Num == HVAC::CoilDX_CurveFit_Speed) {
+    } else if (this->coilType == HVAC::CoilType::CoolingDXCurveFit) {
         if (this->isEpJSON) {
             this->sizingString = "gross_sensible_heat_ratio";
         } else {
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletHumRatSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletHumRatSizing.cc
index b91823fae1e..c4c386809c4 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletHumRatSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletHumRatSizing.cc
@@ -105,7 +105,7 @@ Real64 CoolingWaterDesAirInletHumRatSizer::size(EnergyPlusData &state, Real64 _o
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, this->compName, this->compType, this->autoSizedValue);
+        ReportCoilSelection::setCoilEntAirHumRat(state, this->compName, this->coilType, this->autoSizedValue);
     return this->autoSizedValue;
 }
 
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletTempSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletTempSizing.cc
index 88b324b5064..8fd6ae7ecc0 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletTempSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirInletTempSizing.cc
@@ -130,8 +130,7 @@ Real64 CoolingWaterDesAirInletTempSizer::size(EnergyPlusData &state, Real64 _ori
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject) {
         if (this->curSysNum <= this->numPrimaryAirSys) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                state, this->compName, this->compType, this->autoSizedValue, this->curSysNum, this->curZoneEqNum);
+            ReportCoilSelection::setCoilEntAirTemp(state, this->compName, this->coilType, this->autoSizedValue, this->curSysNum, this->curZoneEqNum);
         }
     }
     return this->autoSizedValue;
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc
index 9ec2877b7f9..e5fb446fbec 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc
@@ -159,7 +159,7 @@ Real64 CoolingWaterDesAirOutletHumRatSizer::size(EnergyPlusData &state, Real64 _
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(state, this->compName, this->compType, this->autoSizedValue);
+        ReportCoilSelection::setCoilLvgAirHumRat(state, this->compName, this->coilType, this->autoSizedValue);
     return this->autoSizedValue;
 }
 
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc
index 48a74104712..b1446d23dc8 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc
@@ -173,7 +173,7 @@ Real64 CoolingWaterDesAirOutletTempSizer::size(EnergyPlusData &state, Real64 _or
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject) {
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, this->compName, this->compType, this->autoSizedValue);
+        ReportCoilSelection::setCoilLvgAirTemp(state, this->compName, this->coilType, this->autoSizedValue);
     }
     return this->autoSizedValue;
 }
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesWaterInletTempSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesWaterInletTempSizing.cc
index 4a975f5870c..53fb6f8548a 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterDesWaterInletTempSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterDesWaterInletTempSizing.cc
@@ -70,7 +70,7 @@ Real64 CoolingWaterDesWaterInletTempSizer::size(EnergyPlusData &state, Real64 _o
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(state, this->compName, this->compType, this->autoSizedValue);
+        ReportCoilSelection::setCoilEntWaterTemp(state, this->compName, this->coilType, this->autoSizedValue);
     return this->autoSizedValue;
 }
 
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc
index 5bb8f63bc8b..b12ce5e8584 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterflowSizing.cc
@@ -137,7 +137,7 @@ Real64 CoolingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue,
     }
     // override sizing string for detailed coil model
     if (this->overrideSizeString) {
-        if (this->coilType_Num == HVAC::Coil_CoolingWaterDetailed) {
+        if (this->coilType == HVAC::CoilType::CoolingWaterDetailed) {
             if (this->isEpJSON) {
                 this->sizingString = "maximum_water_flow_rate [m3/s]";
             } else {
@@ -149,18 +149,15 @@ Real64 CoolingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue,
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject) {
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(
-            state, this->compName, this->compType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizCoolNum, this->dataWaterLoopNum);
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(state, this->compName, this->compType, CoilDesWaterDeltaT);
+        ReportCoilSelection::setCoilWaterFlowPltSizNum(
+            state, this->compName, this->coilType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizCoolNum, this->dataWaterLoopNum);
+        ReportCoilSelection::setCoilWaterDeltaT(state, this->compName, this->coilType, CoilDesWaterDeltaT);
         if (this->dataDesInletWaterTemp > 0.0) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(
-                state, this->compName, this->compType, this->dataDesInletWaterTemp);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
-                state, this->compName, this->compType, this->dataDesInletWaterTemp + CoilDesWaterDeltaT);
+            ReportCoilSelection::setCoilEntWaterTemp(state, this->compName, this->coilType, this->dataDesInletWaterTemp);
+            ReportCoilSelection::setCoilLvgWaterTemp(state, this->compName, this->coilType, this->dataDesInletWaterTemp + CoilDesWaterDeltaT);
         } else {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(state, this->compName, this->compType, Constant::CWInitConvTemp);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
-                state, this->compName, this->compType, Constant::CWInitConvTemp + CoilDesWaterDeltaT);
+            ReportCoilSelection::setCoilEntWaterTemp(state, this->compName, this->coilType, Constant::CWInitConvTemp);
+            ReportCoilSelection::setCoilLvgWaterTemp(state, this->compName, this->coilType, Constant::CWInitConvTemp + CoilDesWaterDeltaT);
         }
     }
     return this->autoSizedValue;
diff --git a/src/EnergyPlus/Autosizing/HeatingAirFlowSizing.cc b/src/EnergyPlus/Autosizing/HeatingAirFlowSizing.cc
index 582af45ff94..0e5ef0b51fc 100644
--- a/src/EnergyPlus/Autosizing/HeatingAirFlowSizing.cc
+++ b/src/EnergyPlus/Autosizing/HeatingAirFlowSizing.cc
@@ -278,8 +278,7 @@ Real64 HeatingAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, b
 
     if (this->isCoilReportObject) {
         // SizingResult is airflow in m3/s
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
-            state, this->compName, this->compType, this->autoSizedValue, this->wasAutoSized);
+        ReportCoilSelection::setCoilAirFlow(state, this->compName, this->coilType, this->autoSizedValue, this->wasAutoSized);
     }
     if (this->isFanReportObject) {
         //  fill fan peak day and time here
diff --git a/src/EnergyPlus/Autosizing/HeatingCapacitySizing.cc b/src/EnergyPlus/Autosizing/HeatingCapacitySizing.cc
index e9b09692fbb..e2b06d4dae5 100644
--- a/src/EnergyPlus/Autosizing/HeatingCapacitySizing.cc
+++ b/src/EnergyPlus/Autosizing/HeatingCapacitySizing.cc
@@ -449,20 +449,20 @@ Real64 HeatingCapacitySizer::size(EnergyPlusData &state, Real64 _originalValue,
 
     if (this->isCoilReportObject) {
         if (CoilInTemp > -999.0) { // set inlet air properties used during capacity sizing if available, allow for negative winter temps
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                state, this->compName, this->compType, CoilInTemp, this->curSysNum, this->curZoneEqNum);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, this->compName, this->compType, CoilInHumRat);
+            ReportCoilSelection::setCoilEntAirTemp(
+                state, this->compName, this->coilType, CoilInTemp, this->curSysNum, this->curZoneEqNum);
+            ReportCoilSelection::setCoilEntAirHumRat(state, this->compName, this->coilType, CoilInHumRat);
         }
         if (CoilOutTemp > -999.0) { // set outlet air properties used during capacity sizing if available
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, this->compName, this->compType, CoilOutTemp);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(state, this->compName, this->compType, CoilOutHumRat);
+            ReportCoilSelection::setCoilLvgAirTemp(state, this->compName, this->coilType, CoilOutTemp);
+            ReportCoilSelection::setCoilLvgAirHumRat(state, this->compName, this->coilType, CoilOutHumRat);
         }
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(state, this->compName, this->compType, DesVolFlow, this->wasAutoSized);
+        ReportCoilSelection::setCoilAirFlow(state, this->compName, this->coilType, DesVolFlow, this->wasAutoSized);
         Real64 constexpr FanCoolLoad = 0.0;
         Real64 constexpr TotCapTempModFac = 1.0;
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(state,
+        ReportCoilSelection::setCoilHeatingCapacity(state,
                                                                                    this->compName,
-                                                                                   this->compType,
+                                                                                   this->coilType,
                                                                                    this->autoSizedValue,
                                                                                    this->wasAutoSized,
                                                                                    this->curSysNum,
diff --git a/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletHumRatSizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletHumRatSizing.cc
index 5da9ab78fc8..a85f864e70e 100644
--- a/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletHumRatSizing.cc
+++ b/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletHumRatSizing.cc
@@ -115,7 +115,7 @@ Real64 HeatingWaterDesAirInletHumRatSizer::size(EnergyPlusData &state, Real64 _o
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, this->compName, this->compType, this->autoSizedValue);
+        ReportCoilSelection::setCoilEntAirHumRat(state, this->compName, this->coilType, this->autoSizedValue);
     return this->autoSizedValue;
 }
 
diff --git a/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletTempSizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletTempSizing.cc
index 952c440acc4..b65df029537 100644
--- a/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletTempSizing.cc
+++ b/src/EnergyPlus/Autosizing/HeatingWaterDesAirInletTempSizing.cc
@@ -124,8 +124,7 @@ Real64 HeatingWaterDesAirInletTempSizer::size(EnergyPlusData &state, Real64 _ori
     // report not written for OA coils and needs to be corrected
     if (this->curSysNum <= this->numPrimaryAirSys) {
         if (this->isCoilReportObject)
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                state, this->compName, this->compType, this->autoSizedValue, this->curSysNum, this->curZoneEqNum);
+            ReportCoilSelection::setCoilEntAirTemp(state, this->compName, this->coilType, this->autoSizedValue, this->curSysNum, this->curZoneEqNum);
     }
     return this->autoSizedValue;
 }
diff --git a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc
index d86dd0acade..877e12b4ef7 100644
--- a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc
+++ b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.cc
@@ -74,7 +74,7 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64
                 Real64 const rho =
                     state.dataPlnt->PlantLoop(this->dataWaterLoopNum).glycol->getDensity(state, Constant::HWInitConvTemp, this->callingRoutine);
                 this->autoSizedValue = this->dataWaterFlowUsedForSizing * this->dataWaterCoilSizHeatDeltaT * Cp * rho;
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(state, this->compName, this->compType, 1.0);
+                ReportCoilSelection::setCoilReheatMultiplier(state, this->compName, this->coilType, 1.0);
             } else if ((this->termUnitPIU || this->termUnitIU) && (this->curTermUnitSizingNum > 0)) {
                 Real64 const Cp =
                     state.dataPlnt->PlantLoop(this->dataWaterLoopNum).glycol->getSpecificHeat(state, Constant::HWInitConvTemp, this->callingRoutine);
@@ -88,7 +88,7 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64
                 Real64 const rho =
                     state.dataPlnt->PlantLoop(this->dataWaterLoopNum).glycol->getDensity(state, Constant::HWInitConvTemp, this->callingRoutine);
                 this->autoSizedValue = this->dataWaterFlowUsedForSizing * this->dataWaterCoilSizHeatDeltaT * Cp * rho;
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(state, this->compName, this->compType, 1.0);
+                ReportCoilSelection::setCoilReheatMultiplier(state, this->compName, this->coilType, 1.0);
             } else {
                 Real64 DesMassFlow = 0.0;
                 if (this->zoneEqSizing(this->curZoneEqNum).SystemAirFlow) {
@@ -178,9 +178,9 @@ Real64 HeatingWaterDesCoilLoadUsedForUASizer::size(EnergyPlusData &state, Real64
         Real64 constexpr TotCapTempModFac = 1.0;
         Real64 constexpr DXFlowPerCapMinRatio = 1.0;
         Real64 constexpr DXFlowPerCapMaxRatio = 1.0;
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(state,
+        ReportCoilSelection::setCoilHeatingCapacity(state,
                                                                                    this->compName,
-                                                                                   this->compType,
+                                                                                   this->coilType,
                                                                                    this->autoSizedValue,
                                                                                    this->wasAutoSized,
                                                                                    this->curSysNum,
diff --git a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.cc
index 857aef7f562..8b9a8f7538e 100644
--- a/src/EnergyPlus/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.cc
+++ b/src/EnergyPlus/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.cc
@@ -81,10 +81,10 @@ Real64 HeatingWaterDesCoilWaterVolFlowUsedForUASizer::size(EnergyPlusData &state
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject) {
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(
-            state, this->compName, this->compType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizHeatNum, this->dataWaterLoopNum);
+        ReportCoilSelection::setCoilWaterFlowPltSizNum(
+            state, this->compName, this->coilType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizHeatNum, this->dataWaterLoopNum);
         if (this->termUnitSingDuct || this->zoneEqFanCoil || ((this->termUnitPIU || this->termUnitIU) && this->curTermUnitSizingNum > 0)) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(state, this->compName, this->compType, 1.0);
+            ReportCoilSelection::setCoilReheatMultiplier(state, this->compName, this->coilType, 1.0);
         }
     }
     return this->autoSizedValue;
diff --git a/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc b/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc
index 4603d47f1d3..6bed5a0c615 100644
--- a/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc
+++ b/src/EnergyPlus/Autosizing/HeatingWaterflowSizing.cc
@@ -143,14 +143,14 @@ Real64 HeatingWaterflowSizer::size(EnergyPlusData &state, Real64 _originalValue,
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject) {
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(
-            state, this->compName, this->compType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizHeatNum, this->dataWaterLoopNum);
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(state, this->compName, this->compType, Constant::HWInitConvTemp);
+        ReportCoilSelection::setCoilWaterFlowPltSizNum(
+            state, this->compName, this->coilType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizHeatNum, this->dataWaterLoopNum);
+        ReportCoilSelection::setCoilEntWaterTemp(state, this->compName, this->coilType, Constant::HWInitConvTemp);
         if (this->plantSizData.size() > 0 && this->dataPltSizHeatNum > 0) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(
-                state, this->compName, this->compType, this->plantSizData(this->dataPltSizHeatNum).DeltaT);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
-                state, this->compName, this->compType, Constant::HWInitConvTemp - this->plantSizData(this->dataPltSizHeatNum).DeltaT);
+            ReportCoilSelection::setCoilWaterDeltaT(
+                state, this->compName, this->coilType, this->plantSizData(this->dataPltSizHeatNum).DeltaT);
+            ReportCoilSelection::setCoilLvgWaterTemp(
+                state, this->compName, this->coilType, Constant::HWInitConvTemp - this->plantSizData(this->dataPltSizHeatNum).DeltaT);
         }
     }
     return this->autoSizedValue;
diff --git a/src/EnergyPlus/Autosizing/SystemAirFlowSizing.cc b/src/EnergyPlus/Autosizing/SystemAirFlowSizing.cc
index 19ca673af03..9da65a9e97d 100644
--- a/src/EnergyPlus/Autosizing/SystemAirFlowSizing.cc
+++ b/src/EnergyPlus/Autosizing/SystemAirFlowSizing.cc
@@ -91,7 +91,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue == this->finalZoneSizing(this->curZoneEqNum).DesHeatVolFlow) {
@@ -102,8 +102,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         } else if (this->autoSizedValue == this->zoneEqSizing(this->curZoneEqNum).AirVolFlow) {
                             DDNameFanPeak = "Unknown";
@@ -118,8 +117,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->zoneHeatingOnlyFan) {
                             this->autoSizedValue = this->finalZoneSizing(this->curZoneEqNum).DesHeatVolFlow;
@@ -130,8 +128,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         } else if (this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow) {
                             this->autoSizedValue = this->zoneEqSizing(this->curZoneEqNum).CoolingAirVolFlow;
@@ -142,8 +139,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
                             this->autoSizedValue = this->zoneEqSizing(this->curZoneEqNum).HeatingAirVolFlow;
@@ -154,8 +150,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
                             this->autoSizedValue = max(this->zoneEqSizing(this->curZoneEqNum).CoolingAirVolFlow,
@@ -168,8 +163,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         format("{}/{} {}",
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                               state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                   state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                               ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                                 }
                             } else if (this->autoSizedValue == this->zoneEqSizing(this->curZoneEqNum).HeatingAirVolFlow) {
                                 if (this->finalZoneSizing(this->curZoneEqNum).HeatDDNum > 0 &&
@@ -179,8 +173,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         format("{}/{} {}",
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                               state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                   state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                               ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                                 }
                             }
                         } else {
@@ -194,8 +187,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         format("{}/{} {}",
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                               state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                   state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                               ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                                 }
                             } else if (this->autoSizedValue == this->finalZoneSizing(this->curZoneEqNum).DesHeatVolFlow) {
                                 if (this->finalZoneSizing(this->curZoneEqNum).HeatDDNum > 0 &&
@@ -205,8 +197,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         format("{}/{} {}",
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                               state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                   state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                               ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                                 }
                             }
                         }
@@ -220,8 +211,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                         state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                                     ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneHeatingOnlyFan) {
                         this->autoSizedValue = this->dataFracOfAutosizedHeatingAirflow * this->finalZoneSizing(this->curZoneEqNum).DesHeatVolFlow;
@@ -231,8 +221,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                         state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                                     ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow) {
                         this->autoSizedValue = this->dataFracOfAutosizedCoolingAirflow * this->zoneEqSizing(this->curZoneEqNum).CoolingAirVolFlow;
@@ -242,8 +231,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                         state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                                     ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
                         this->autoSizedValue = this->dataFracOfAutosizedHeatingAirflow * this->zoneEqSizing(this->curZoneEqNum).HeatingAirVolFlow;
@@ -253,8 +241,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                         state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                                     ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
                         this->autoSizedValue =
@@ -269,8 +256,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue ==
                                    this->dataFracOfAutosizedHeatingAirflow * this->zoneEqSizing(this->curZoneEqNum).HeatingAirVolFlow) {
@@ -281,8 +267,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
                     } else {
@@ -298,8 +283,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue ==
                                    this->dataFracOfAutosizedHeatingAirflow * this->finalZoneSizing(this->curZoneEqNum).DesHeatVolFlow) {
@@ -310,8 +294,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                               state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
+                                           ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
                     }
@@ -324,8 +307,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
-                                                         state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
+                                                     ReportCoilSelection::getTimeText(state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneHeatingOnlyFan) {
                         this->autoSizedValue = this->dataFracOfAutosizedHeatingAirflow * this->finalZoneSizing(this->curZoneEqNum).DesHeatVolFlow;
@@ -335,7 +317,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow) {
@@ -346,7 +328,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -357,7 +339,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -373,7 +355,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue ==
@@ -385,7 +367,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
@@ -402,7 +384,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue ==
@@ -414,7 +396,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
@@ -428,7 +410,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneHeatingOnlyFan) {
@@ -439,7 +421,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow) {
@@ -450,7 +432,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -461,7 +443,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -475,7 +457,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue == this->dataFlowPerHeatingCapacity * this->dataAutosizedHeatingCapacity) {
@@ -486,7 +468,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
@@ -501,7 +483,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue == this->dataFlowPerHeatingCapacity * this->dataAutosizedHeatingCapacity) {
@@ -512,7 +494,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
@@ -526,7 +508,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneHeatingOnlyFan) {
@@ -537,7 +519,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow) {
@@ -548,7 +530,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -559,7 +541,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -573,7 +555,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue == this->dataFlowPerHeatingCapacity * this->dataAutosizedHeatingCapacity) {
@@ -584,7 +566,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
@@ -599,7 +581,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue == this->dataFlowPerHeatingCapacity * this->dataAutosizedHeatingCapacity) {
@@ -610,7 +592,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
@@ -624,7 +606,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && !this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -635,7 +617,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                             dateTimeFanPeak = format("{}/{} {}",
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                      state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                                     state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                     ReportCoilSelection::getTimeText(
                                                          state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                         }
                     } else if (this->zoneEqSizing(this->curZoneEqNum).HeatingAirFlow && this->zoneEqSizing(this->curZoneEqNum).CoolingAirFlow) {
@@ -649,7 +631,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->autoSizedValue == this->zoneEqSizing(this->curZoneEqNum).HeatingAirVolFlow) {
@@ -660,7 +642,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         }
@@ -678,7 +660,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                             }
                         } else if (this->zoneHeatingOnlyFan) {
@@ -690,7 +672,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     format("{}/{} {}",
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                            state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                           state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                           ReportCoilSelection::getTimeText(
                                                state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                             }
                         } else {
@@ -704,7 +686,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         format("{}/{} {}",
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).Month,
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).CoolDDNum).DayOfMonth,
-                                               state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                               ReportCoilSelection::getTimeText(
                                                    state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtCoolMax));
                                 }
                             } else if (this->autoSizedValue == this->finalZoneSizing(this->curZoneEqNum).DesHeatVolFlow) {
@@ -715,7 +697,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         format("{}/{} {}",
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).Month,
                                                state.dataWeather->DesDayInput(this->finalZoneSizing(this->curZoneEqNum).HeatDDNum).DayOfMonth,
-                                               state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                               ReportCoilSelection::getTimeText(
                                                    state, this->finalZoneSizing(this->curZoneEqNum).TimeStepNumAtHeatMax));
                                 }
                             }
@@ -804,7 +786,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     dateTimeFanPeak = format("{}/{} {}",
                                                              desDayInput.Month,
                                                              desDayInput.DayOfMonth,
-                                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                             ReportCoilSelection::getTimeText(
                                                                  state, this->finalSysSizing(this->curSysNum).SysHeatAirTimeStepPk));
                                 }
                             } else if (this->autoSizedValue == this->finalSysSizing(this->curSysNum).DesCoolVolFlow) {
@@ -815,7 +797,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     dateTimeFanPeak = format("{}/{} {}",
                                                              desDayInput.Month,
                                                              desDayInput.DayOfMonth,
-                                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                             ReportCoilSelection::getTimeText(
                                                                  state, sysSizPeakDDNum.TimeStepAtCoolFlowPk(sysSizPeakDDNum.CoolFlowPeakDD)));
                                 }
                             }
@@ -834,7 +816,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         dateTimeFanPeak = format("{}/{} {}",
                                                                  desDayInput.Month,
                                                                  desDayInput.DayOfMonth,
-                                                                 state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                                 ReportCoilSelection::getTimeText(
                                                                      state, sysSizPeakDDNum.TimeStepAtCoolFlowPk(sysSizPeakDDNum.CoolFlowPeakDD)));
                                     }
 
@@ -846,7 +828,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         dateTimeFanPeak = format("{}/{} {}",
                                                                  desDayInput.Month,
                                                                  desDayInput.DayOfMonth,
-                                                                 state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                                 ReportCoilSelection::getTimeText(
                                                                      state, this->finalSysSizing(this->curSysNum).SysHeatAirTimeStepPk));
                                     }
                                 }
@@ -858,7 +840,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     dateTimeFanPeak = format("{}/{} {}",
                                                              desDayInput.Month,
                                                              desDayInput.DayOfMonth,
-                                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                             ReportCoilSelection::getTimeText(
                                                                  state, sysSizPeakDDNum.TimeStepAtCoolFlowPk(sysSizPeakDDNum.CoolFlowPeakDD)));
                                 }
                             } else if (unitarysysEqSizing.HeatingAirFlow) {
@@ -870,7 +852,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     dateTimeFanPeak = format("{}/{} {}",
                                                              desDayInput.Month,
                                                              desDayInput.DayOfMonth,
-                                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                             ReportCoilSelection::getTimeText(
                                                                  state, this->finalSysSizing(this->curSysNum).SysHeatAirTimeStepPk));
                                 }
 
@@ -884,7 +866,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         dateTimeFanPeak = format("{}/{} {}",
                                                                  desDayInput.Month,
                                                                  desDayInput.DayOfMonth,
-                                                                 state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                                 ReportCoilSelection::getTimeText(
                                                                      state, this->finalSysSizing(this->curSysNum).SysHeatAirTimeStepPk));
                                     }
                                 } else if (this->autoSizedValue == this->finalSysSizing(this->curSysNum).DesCoolVolFlow) {
@@ -894,7 +876,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                         dateTimeFanPeak = format("{}/{} {}",
                                                                  desDayInput.Month,
                                                                  desDayInput.DayOfMonth,
-                                                                 state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                                 ReportCoilSelection::getTimeText(
                                                                      state, sysSizPeakDDNum.TimeStepAtCoolFlowPk(sysSizPeakDDNum.CoolFlowPeakDD)));
                                     }
                                 }
@@ -909,7 +891,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     dateTimeFanPeak = format("{}/{} {}",
                                                              desDayInput.Month,
                                                              desDayInput.DayOfMonth,
-                                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                             ReportCoilSelection::getTimeText(
                                                                  state, this->finalSysSizing(this->curSysNum).SysHeatAirTimeStepPk));
                                 }
                             } else if (this->autoSizedValue == this->finalSysSizing(this->curSysNum).DesCoolVolFlow) {
@@ -919,7 +901,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
                                     dateTimeFanPeak = format("{}/{} {}",
                                                              desDayInput.Month,
                                                              desDayInput.DayOfMonth,
-                                                             state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(
+                                                             ReportCoilSelection::getTimeText(
                                                                  state, sysSizPeakDDNum.TimeStepAtCoolFlowPk(sysSizPeakDDNum.CoolFlowPeakDD)));
                                 }
                             }
@@ -976,7 +958,7 @@ Real64 SystemAirFlowSizer::size(EnergyPlusData &state, Real64 _originalValue, bo
     this->selectSizerOutput(state, errorsFound);
     if (this->isFanReportObject) {
         //  fill fan peak day and time here
-        if (state.dataRptCoilSelection->coilSelectionReportObj->isCompTypeFan(this->compType)) {
+        if (ReportCoilSelection::isCompTypeFan(this->compType)) {
             if (this->dataScalableSizingON) {
                 DDNameFanPeak = "Scaled size, not from any peak";
                 dateTimeFanPeak = "Scaled size, not from any peak";
diff --git a/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc b/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc
index 7fcd86f0f59..49a1319aef9 100644
--- a/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc
+++ b/src/EnergyPlus/Autosizing/WaterHeatingCapacitySizing.cc
@@ -148,8 +148,8 @@ Real64 WaterHeatingCapacitySizer::size(EnergyPlusData &state, Real64 _originalVa
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject)
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterHeaterCapacityPltSizNum(
-            state, this->compName, this->compType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizHeatNum, this->dataWaterLoopNum);
+        ReportCoilSelection::setCoilWaterHeaterCapacityPltSizNum(
+            state, this->compName, this->coilType, this->autoSizedValue, this->wasAutoSized, this->dataPltSizHeatNum, this->dataWaterLoopNum);
     return this->autoSizedValue;
 }
 
diff --git a/src/EnergyPlus/Autosizing/WaterHeatingCoilUASizing.cc b/src/EnergyPlus/Autosizing/WaterHeatingCoilUASizing.cc
index 3a5a60cbaec..d1a9cc1e882 100644
--- a/src/EnergyPlus/Autosizing/WaterHeatingCoilUASizing.cc
+++ b/src/EnergyPlus/Autosizing/WaterHeatingCoilUASizing.cc
@@ -391,9 +391,9 @@ Real64 WaterHeatingCoilUASizer::size(EnergyPlusData &state, Real64 _originalValu
     }
     this->selectSizerOutput(state, errorsFound);
     if (this->isCoilReportObject && this->curSysNum <= state.dataHVACGlobal->NumPrimaryAirSys) {
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilUA(state,
+        ReportCoilSelection::setCoilUA(state,
                                                                       this->compName,
-                                                                      this->compType,
+                                                                      this->coilType,
                                                                       this->autoSizedValue,
                                                                       this->dataCapacityUsedForSizing,
                                                                       this->wasAutoSized,
diff --git a/src/EnergyPlus/Coils/CoilCoolingDX.cc b/src/EnergyPlus/Coils/CoilCoolingDX.cc
index 4596c3165a6..6702ea8ca38 100644
--- a/src/EnergyPlus/Coils/CoilCoolingDX.cc
+++ b/src/EnergyPlus/Coils/CoilCoolingDX.cc
@@ -95,7 +95,7 @@ int CoilCoolingDX::factory(EnergyPlus::EnergyPlusData &state, std::string const
 
 void CoilCoolingDX::getInput(EnergyPlusData &state)
 {
-    int numCoolingCoilDXs = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataCoilCoolingDX->coilCoolingDXObjectName);
+    int numCoolingCoilDXs = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::coilTypeNames[(int)state.dataCoilCoolingDX->coilType]);
     if (numCoolingCoilDXs <= 0) {
         ShowFatalError(state, R"(No "Coil:Cooling:DX" objects in input file)");
     }
@@ -104,7 +104,7 @@ void CoilCoolingDX::getInput(EnergyPlusData &state)
         int NumNumbers; // Number of Numbers for each GetObjectItem call
         int IOStatus;
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 state.dataCoilCoolingDX->coilCoolingDXObjectName,
+                                                                 HVAC::coilTypeNames[(int)state.dataCoilCoolingDX->coilType],
                                                                  coilNum,
                                                                  state.dataIPShortCut->cAlphaArgs,
                                                                  NumAlphas,
@@ -135,13 +135,13 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo
     ErrorObjectHeader eoh{routineName, "CoilCoolingDX", input_data.name};
 
     this->original_input_specs = input_data;
+
     bool errorsFound = false;
     this->name = input_data.name;
 
     // initialize reclaim heat parameters
     this->reclaimHeat.Name = this->name;
-    this->reclaimHeat.SourceType = state.dataCoilCoolingDX->coilCoolingDXObjectName;
-
+    this->reclaimHeat.SourceType = HVAC::coilTypeNames[(int)state.dataCoilCoolingDX->coilType];
     this->performance = CoilCoolingDXCurveFitPerformance(state, input_data.performance_object_name);
 
     if (!this->performance.original_input_specs.base_operating_mode_name.empty() &&
@@ -193,7 +193,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo
     if (!input_data.condensate_collection_water_storage_tank_name.empty()) {
         WaterManager::SetupTankSupplyComponent(state,
                                                this->name,
-                                               state.dataCoilCoolingDX->coilCoolingDXObjectName,
+                                               HVAC::coilTypeNames[(int)state.dataCoilCoolingDX->coilType],
                                                input_data.condensate_collection_water_storage_tank_name,
                                                errorsFound,
                                                this->condensateTankIndex,
@@ -203,7 +203,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo
     if (!input_data.evaporative_condenser_supply_water_storage_tank_name.empty()) {
         WaterManager::SetupTankDemandComponent(state,
                                                this->name,
-                                               state.dataCoilCoolingDX->coilCoolingDXObjectName,
+                                               HVAC::coilTypeNames[(int)state.dataCoilCoolingDX->coilType], // Can this be more than coils?
                                                input_data.evaporative_condenser_supply_water_storage_tank_name,
                                                errorsFound,
                                                this->evaporativeCondSupplyTankIndex,
@@ -223,7 +223,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo
     }
 
     BranchNodeConnections::TestCompSet(state,
-                                       state.dataCoilCoolingDX->coilCoolingDXObjectName,
+                                       HVAC::coilTypeNames[(int)state.dataCoilCoolingDX->coilType],
                                        this->name,
                                        input_data.evaporator_inlet_node_name,
                                        input_data.evaporator_outlet_node_name,
@@ -231,8 +231,8 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo
 
     if (errorsFound) {
         ShowFatalError(state,
-                       std::string{routineName} + "Errors found in getting " + state.dataCoilCoolingDX->coilCoolingDXObjectName +
-                           " input. Preceding condition(s) causes termination.");
+                       format("{}: Errors found in getting {}  input. Preceding conditions causes termination.",
+                              HVAC::coilTypeNames[(int)state.dataCoilCoolingDX->coilType]));
     }
 }
 
@@ -801,23 +801,23 @@ void CoilCoolingDX::simulate(EnergyPlusData &state,
             // report out final coil sizing info
             Real64 ratedSensCap(0.0);
             ratedSensCap = this->performance.normalMode.ratedGrossTotalCap * this->normModeNomSpeed().grossRatedSHR;
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
-                                                                                  this->name,
-                                                                                  state.dataCoilCoolingDX->coilCoolingDXObjectName,
-                                                                                  this->performance.normalMode.ratedGrossTotalCap,
-                                                                                  ratedSensCap,
-                                                                                  this->performance.normalMode.ratedEvapAirFlowRate,
-                                                                                  -999.0);
+            ReportCoilSelection::setCoilFinalSizes(state,
+                                                   this->name,
+                                                   state.dataCoilCoolingDX->coilType,
+                                                   this->performance.normalMode.ratedGrossTotalCap,
+                                                   ratedSensCap,
+                                                   this->performance.normalMode.ratedEvapAirFlowRate,
+                                                   -999.0);
 
             // report out fan information
             // should work for all fan types
             if (this->supplyFanIndex > 0) {
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(state,
-                                                                                         this->name,
-                                                                                         state.dataCoilCoolingDX->coilCoolingDXObjectName,
-                                                                                         state.dataFans->fans(this->supplyFanIndex)->Name,
-                                                                                         state.dataFans->fans(this->supplyFanIndex)->type,
-                                                                                         this->supplyFanIndex);
+                ReportCoilSelection::setCoilSupplyFanInfo(state,
+                                                          this->name,
+                                                          state.dataCoilCoolingDX->coilType,
+                                                          state.dataFans->fans(this->supplyFanIndex)->Name,
+                                                          state.dataFans->fans(this->supplyFanIndex)->type,
+                                                          this->supplyFanIndex);
             }
 
             // report out coil rating conditions, just create a set of dummy nodes and run calculate on them
@@ -897,22 +897,22 @@ void CoilCoolingDX::simulate(EnergyPlusData &state,
 
             Real64 const ratedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
                 state, dummyEvapOutlet.Temp, dummyEvapOutlet.HumRat, DataEnvironment::StdPressureSeaLevel, "Coil:Cooling:DX::simulate");
-            state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(state,
-                                                                                       this->name,
-                                                                                       state.dataCoilCoolingDX->coilCoolingDXObjectName,
-                                                                                       coolingRate,
-                                                                                       sensCoolingRate,
-                                                                                       ratedInletEvapMassFlowRate,
-                                                                                       RatedInletAirTemp,
-                                                                                       dummyInletAirHumRat,
-                                                                                       RatedInletWetBulbTemp,
-                                                                                       dummyEvapOutlet.Temp,
-                                                                                       dummyEvapOutlet.HumRat,
-                                                                                       ratedOutletWetBulb,
-                                                                                       RatedOutdoorAirTemp,
-                                                                                       ratedOutdoorAirWetBulb,
-                                                                                       this->normModeNomSpeed().RatedCBF,
-                                                                                       -999.0);
+            ReportCoilSelection::setRatedCoilConditions(state,
+                                                        this->name,
+                                                        state.dataCoilCoolingDX->coilType,
+                                                        coolingRate,
+                                                        sensCoolingRate,
+                                                        ratedInletEvapMassFlowRate,
+                                                        RatedInletAirTemp,
+                                                        dummyInletAirHumRat,
+                                                        RatedInletWetBulbTemp,
+                                                        dummyEvapOutlet.Temp,
+                                                        dummyEvapOutlet.HumRat,
+                                                        ratedOutletWetBulb,
+                                                        RatedOutdoorAirTemp,
+                                                        ratedOutdoorAirWetBulb,
+                                                        this->normModeNomSpeed().RatedCBF,
+                                                        -999.0);
 
             this->reportCoilFinalSizes = false;
         }
diff --git a/src/EnergyPlus/Coils/CoilCoolingDX.hh b/src/EnergyPlus/Coils/CoilCoolingDX.hh
index ad59c1356be..4916b94d51e 100644
--- a/src/EnergyPlus/Coils/CoilCoolingDX.hh
+++ b/src/EnergyPlus/Coils/CoilCoolingDX.hh
@@ -179,7 +179,7 @@ struct CoilCoolingDXData : BaseGlobalStruct
 {
     std::vector<CoilCoolingDX> coilCoolingDXs;
     bool coilCoolingDXGetInputFlag = true;
-    std::string const coilCoolingDXObjectName = "Coil:Cooling:DX";
+    HVAC::CoilType coilType = HVAC::CoilType::CoolingDX; // Why is this a state variable and not an object member variable?
     bool stillNeedToReportStandardRatings = true; // standard ratings flag for all coils to report at the same time
 
     void init_constant_state([[maybe_unused]] EnergyPlusData &state) override
diff --git a/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc b/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc
index 9c1a2d6b354..04711bfad58 100644
--- a/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc
+++ b/src/EnergyPlus/Coils/CoilCoolingDXCurveFitPerformance.cc
@@ -571,7 +571,7 @@ void CoilCoolingDXCurveFitPerformance::calcStandardRatings210240(EnergyPlus::Ene
             std::tie(this->standardRatingCoolingCapacity2023,
                      this->standardRatingSEER2_User,
                      this->standardRatingSEER2_Standard,
-                     this->standardRatingEER2) = StandardRatings::SEER2CalulcationCurveFit(state, "Coil:Cooling:DX:CurveFit", this->normalMode);
+                     this->standardRatingEER2) = StandardRatings::SEER2CalulcationCurveFit(state, HVAC::CoilType::CoolingDXCurveFit, this->normalMode);
         }
 
         // IEER calculations: Capacity of 65K Btu/h (19050 W) to less than 135K Btu/h (39565 W) - calculated as per AHRI Standard 340/360-2022.
@@ -613,7 +613,7 @@ void CoilCoolingDXCurveFitPerformance::calcStandardRatings210240(EnergyPlus::Ene
         // TODO: we can always decide and give precedence to Alternate Mode 1 or Alternate Mode 2 if present | Needs Discussion about the
         // applicability.
         std::tie(this->standardRatingIEER2, this->standardRatingCoolingCapacity2023, this->standardRatingEER2) =
-            StandardRatings::IEERCalulcationCurveFit(state, "Coil:Cooling:DX:CurveFit", this->normalMode);
+          StandardRatings::IEERCalulcationCurveFit(state, HVAC::CoilType::CoolingDXCurveFit, this->normalMode);
 
     } else {
         ShowSevereError(state,
diff --git a/src/EnergyPlus/CostEstimateManager.cc b/src/EnergyPlus/CostEstimateManager.cc
index fea2c41eee9..f4e86a91cd2 100644
--- a/src/EnergyPlus/CostEstimateManager.cc
+++ b/src/EnergyPlus/CostEstimateManager.cc
@@ -798,7 +798,7 @@ namespace CostEstimateManager {
                     if (WildcardObjNames) {
                         Real64 Qty(0.0);
                         for (auto const &e : state.dataHeatingCoils->HeatingCoil)
-                            if (e.HCoilType_Num == 1) Qty += e.NominalCapacity;
+                          if (e.coilType == HVAC::CoilType::CoolingDXSingleSpeed) Qty += e.NominalCapacity;
                         state.dataCostEstimateManager->CostLineItem(Item).Qty = Qty / 1000.0;
                         state.dataCostEstimateManager->CostLineItem(Item).Units = "kW (tot heat cap.)";
                         state.dataCostEstimateManager->CostLineItem(Item).ValuePer = state.dataCostEstimateManager->CostLineItem(Item).PerKiloWattCap;
@@ -828,7 +828,7 @@ namespace CostEstimateManager {
                     if (WildcardObjNames) {
                         Real64 Qty(0.0);
                         for (auto const &e : state.dataHeatingCoils->HeatingCoil)
-                            if (e.HCoilType_Num == 1) Qty += e.Efficiency * e.NominalCapacity;
+                            if (e.coilType == HVAC::CoilType::CoolingDXSingleSpeed) Qty += e.Efficiency * e.NominalCapacity;
                         state.dataCostEstimateManager->CostLineItem(Item).Qty = Qty / 1000.0;
                         state.dataCostEstimateManager->CostLineItem(Item).Units = "kW*Eff (total, rated) ";
                         state.dataCostEstimateManager->CostLineItem(Item).ValuePer = state.dataCostEstimateManager->CostLineItem(Item).PerKWCapPerCOP;
diff --git a/src/EnergyPlus/DXCoils.cc b/src/EnergyPlus/DXCoils.cc
index 1c4c5abd726..725d87c93de 100644
--- a/src/EnergyPlus/DXCoils.cc
+++ b/src/EnergyPlus/DXCoils.cc
@@ -151,8 +151,6 @@ void SimDXCoil(EnergyPlusData &state,
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
     int DXCoilNum;       // index of fan coil unit being simulated
-    Real64 AirFlowRatio; // ratio of compressor on airflow to compressor off airflow
-    Real64 CompCycRatio; // compressor cycling ratio of VRF condenser
 
     // First time SimDXCoil is called, get the input for all the DX coils (condensing units)
     if (state.dataDXCoils->GetCoilsInputFlag) {
@@ -187,6 +185,27 @@ void SimDXCoil(EnergyPlusData &state,
         }
     }
 
+
+    SimDXCoil(state, DXCoilNum, compressorOp, FirstHVACIteration, fanOp, PartLoadRatio, OnOffAFR, CoilCoolingHeatingPLRRatio, MaxCap, CompCyclingRatio);
+}
+
+void SimDXCoil(EnergyPlusData &state,
+               int const coilNum,
+               HVAC::CompressorOp const compressorOp, // compressor operation; 1=on, 0=off
+               bool const FirstHVACIteration,         // True when first HVAC iteration
+               HVAC::FanOp const fanOp,                                      // allows parent object to control fan mode
+               ObjexxFCL::Optional<Real64 const> PartLoadRatio,              // part load ratio (for single speed cycling unit)
+               ObjexxFCL::Optional<Real64 const> OnOffAFR,                   // ratio of compressor on airflow to compressor off airflow
+               ObjexxFCL::Optional<Real64 const> CoilCoolingHeatingPLRRatio, // used for cycling fan RH control
+               ObjexxFCL::Optional<Real64 const> MaxCap,                     // maximum cooling capacity of VRF terminal units
+               ObjexxFCL::Optional<Real64 const> CompCyclingRatio            // cycling ratio of VRF condenser connected to this TU
+)
+{
+    assert(coilNum > 0&& coilNum <= state.dataDXCoils->NumDXCoils);
+  
+    Real64 AirFlowRatio; // ratio of compressor on airflow to compressor off airflow
+    Real64 CompCycRatio; // compressor cycling ratio of VRF condenser
+
     if (present(OnOffAFR)) {
         AirFlowRatio = OnOffAFR;
     } else {
@@ -200,53 +219,59 @@ void SimDXCoil(EnergyPlusData &state,
     }
 
     // Initialize the DX coil unit
-    InitDXCoil(state, DXCoilNum);
+    InitDXCoil(state, coilNum);
 
     // Select the correct unit type
-    switch (state.dataDXCoils->DXCoil(DXCoilNum).DXCoilType_Num) { // Autodesk:OPTIONAL PartLoadRatio, MaxCap used in this block without PRESENT check
-    case HVAC::CoilDX_CoolingSingleSpeed: {
+    switch (state.dataDXCoils->DXCoil(coilNum).coilType) { // Autodesk:OPTIONAL PartLoadRatio, MaxCap used in this block without PRESENT check
+    case HVAC::CoilType::CoolingDXSingleSpeed: {
         if (present(CoilCoolingHeatingPLRRatio)) {
-            CalcDoe2DXCoil(state, DXCoilNum, compressorOp, FirstHVACIteration, PartLoadRatio, fanOp, _, AirFlowRatio, CoilCoolingHeatingPLRRatio);
+            CalcDoe2DXCoil(state, coilNum, compressorOp, FirstHVACIteration, PartLoadRatio, fanOp, _, AirFlowRatio, CoilCoolingHeatingPLRRatio);
         } else {
-            CalcDoe2DXCoil(state, DXCoilNum, compressorOp, FirstHVACIteration, PartLoadRatio, fanOp, _, AirFlowRatio);
+            CalcDoe2DXCoil(state, coilNum, compressorOp, FirstHVACIteration, PartLoadRatio, fanOp, _, AirFlowRatio);
         }
     } break;
-    case HVAC::CoilDX_HeatingEmpirical: {
-        CalcDXHeatingCoil(state, DXCoilNum, PartLoadRatio, fanOp, AirFlowRatio);
+      
+    case HVAC::CoilType::HeatingDXSingleSpeed: {
+        CalcDXHeatingCoil(state, coilNum, PartLoadRatio, fanOp, AirFlowRatio);
     } break;
-    case HVAC::CoilDX_HeatPumpWaterHeaterPumped:
-    case HVAC::CoilDX_HeatPumpWaterHeaterWrapped: {
+      
+    case HVAC::CoilType::WaterHeatingDXPumped:
+    case HVAC::CoilType::WaterHeatingDXWrapped: {
         //   call the HPWHDXCoil routine to calculate water side performance set up the DX coil info for air-side calcs
-        CalcHPWHDXCoil(state, DXCoilNum, PartLoadRatio);
+        CalcHPWHDXCoil(state, coilNum, PartLoadRatio);
         //    CALL CalcDoe2DXCoil(state, DXCoilNum, compressorOp, FirstHVACIteration,PartLoadRatio), perform air-side calculations
-        CalcDoe2DXCoil(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp);
+        CalcDoe2DXCoil(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp);
     } break;
-    case HVAC::CoilVRF_Cooling: {
-        CalcVRFCoolingCoil(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp, CompCycRatio, _, AirFlowRatio, MaxCap);
+      
+    case HVAC::CoilType::CoolingVRF: {
+        CalcVRFCoolingCoil(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp, CompCycRatio, _, AirFlowRatio, MaxCap);
     } break;
-    case HVAC::CoilVRF_Heating: {
-        CalcDXHeatingCoil(state, DXCoilNum, PartLoadRatio, fanOp, AirFlowRatio, MaxCap);
+      
+    case HVAC::CoilType::HeatingVRF: {
+        CalcDXHeatingCoil(state, coilNum, PartLoadRatio, fanOp, AirFlowRatio, MaxCap);
     } break;
-    case HVAC::CoilVRF_FluidTCtrl_Cooling: {
-        CalcVRFCoolingCoil_FluidTCtrl(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp, CompCycRatio, _, _, MaxCap);
+      
+    case HVAC::CoilType::CoolingVRFFluidTCtrl: {
+        CalcVRFCoolingCoil_FluidTCtrl(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp, CompCycRatio, _, _, MaxCap);
     } break;
-    case HVAC::CoilVRF_FluidTCtrl_Heating: {
-        CalcVRFHeatingCoil_FluidTCtrl(state, compressorOp, DXCoilNum, PartLoadRatio, fanOp, _, MaxCap);
+
+      // Why is coilNum after compressorOp in this function? Really, why?
+    case HVAC::CoilType::HeatingVRFFluidTCtrl: {
+        CalcVRFHeatingCoil_FluidTCtrl(state, compressorOp, coilNum, PartLoadRatio, fanOp, _, MaxCap);
     } break;
+      
     default: {
-        ShowSevereError(state, format("Error detected in DX Coil={}", CompName));
-        ShowContinueError(state, format("Invalid DX Coil Type={}", state.dataDXCoils->DXCoil(DXCoilNum).DXCoilType));
-        ShowFatalError(state, "Preceding condition causes termination.");
+        assert(false);
     } break;
     }
 
     // Update the unit outlet nodes
-    UpdateDXCoil(state, DXCoilNum);
+    UpdateDXCoil(state, coilNum);
 
     // Report the result of the simulation
-    ReportDXCoil(state, DXCoilNum);
+    ReportDXCoil(state, coilNum);
 }
-
+  
 void SimDXCoilMultiSpeed(EnergyPlusData &state,
                          std::string_view CompName, // name of the fan coil unit
                          Real64 const SpeedRatio,   // = (CompressorSpeed - CompressorSpeedMin) /
@@ -314,6 +339,31 @@ void SimDXCoilMultiSpeed(EnergyPlusData &state,
         }
     }
 
+    SimDXCoilMultiSpeed(state, DXCoilNum, SpeedRatio, CycRatio, SpeedNum, fanOp, compressorOp, SingleMode);
+}
+
+void SimDXCoilMultiSpeed(EnergyPlusData &state,
+                         int const coilNum,
+                         Real64 const SpeedRatio,   // = (CompressorSpeed - CompressorSpeedMin) /
+                         Real64 const CycRatio,     // cycling part load ratio for variable speed
+                         ObjexxFCL::Optional_int_const SpeedNum,       // Speed number for multispeed cooling coil only
+                         ObjexxFCL::Optional<HVAC::FanOp const> fanOp, // Fan operation mode
+                         HVAC::CompressorOp compressorOp,              // Compressor on/off; 1=on, 0=off
+                         ObjexxFCL::Optional_int_const SingleMode      // Single mode operation Yes/No; 1=Yes, 0=No
+)
+{
+
+    // SUBROUTINE INFORMATION:
+    //       AUTHOR         Fred Buhl
+    //       DATE WRITTEN   September 2002
+    //       MODIFIED       Lixing Gu, Sep. 2007
+
+    // PURPOSE OF THIS SUBROUTINE:
+    // Manages the simulation of a multi speed DX coil.
+
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+
+    int SingleModeOper; // SingleMode Operation
     if (present(SingleMode)) {
         SingleModeOper = SingleMode;
     } else {
@@ -321,17 +371,19 @@ void SimDXCoilMultiSpeed(EnergyPlusData &state,
     }
 
     // Initialize the DX coil unit
-    InitDXCoil(state, DXCoilNum);
+    InitDXCoil(state, coilNum);
 
     // Select the correct unit type
-    switch (state.dataDXCoils->DXCoil(DXCoilNum).DXCoilType_Num) {
-    case HVAC::CoilDX_CoolingTwoSpeed: {
-        CalcMultiSpeedDXCoil(state, DXCoilNum, SpeedRatio, CycRatio);
+    switch (state.dataDXCoils->DXCoil(coilNum).coilType) {
+
+    case HVAC::CoilType::CoolingDXTwoSpeed: {
+        CalcMultiSpeedDXCoil(state, coilNum, SpeedRatio, CycRatio);
     } break;
-    case HVAC::CoilDX_MultiSpeedCooling: {
+      
+    case HVAC::CoilType::CoolingDXMultiSpeed: {
         if (present(SpeedNum))
             CalcMultiSpeedDXCoilCooling(state,
-                                        DXCoilNum,
+                                        coilNum,
                                         SpeedRatio,
                                         CycRatio,
                                         SpeedNum,
@@ -340,10 +392,11 @@ void SimDXCoilMultiSpeed(EnergyPlusData &state,
                                         SingleModeOper); // Autodesk:OPTIONAL fanOp, CompressorOp used without PRESENT check
 
     } break;
-    case HVAC::CoilDX_MultiSpeedHeating: {
+      
+    case HVAC::CoilType::HeatingDXMultiSpeed: {
         if (present(SpeedNum))
             CalcMultiSpeedDXCoilHeating(state,
-                                        DXCoilNum,
+                                        coilNum,
                                         SpeedRatio,
                                         CycRatio,
                                         SpeedNum,
@@ -352,17 +405,15 @@ void SimDXCoilMultiSpeed(EnergyPlusData &state,
 
     } break;
     default: {
-        ShowSevereError(state, format("Error detected in DX Coil={}", CompName));
-        ShowContinueError(state, format("Invalid DX Coil Type={}", state.dataDXCoils->DXCoil(DXCoilNum).DXCoilType));
-        ShowFatalError(state, "Preceding condition causes termination.");
+        assert(false);
     } break;
     }
 
     // Update the unit outlet nodes
-    UpdateDXCoil(state, DXCoilNum);
+    UpdateDXCoil(state, coilNum);
 
     // Report the result of the simulation
-    ReportDXCoil(state, DXCoilNum);
+    ReportDXCoil(state, coilNum);
 }
 
 void SimDXCoilMultiMode(EnergyPlusData &state,
@@ -375,7 +426,65 @@ void SimDXCoilMultiMode(EnergyPlusData &state,
                         HVAC::FanOp const fanOp // allows parent object to control fan mode
 )
 {
+    // Using/Aliasing
 
+    // SUBROUTINE PARAMETER DEFINITIONS:
+    static constexpr std::string_view RoutineName("SimDXCoilMultiMode");
+
+    // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
+    int DXCoilNum; // index of coil being simulated
+    // First time SimDXCoil is called, get the input for all the DX coils (condensing units)
+    if (state.dataDXCoils->GetCoilsInputFlag) {
+        GetDXCoils(state);
+        state.dataDXCoils->GetCoilsInputFlag = false; // Set GetInputFlag false so you don't get coil inputs again
+    }
+
+    //  find correct DX Coil
+    if (CompIndex == 0) {
+        DXCoilNum = Util::FindItemInList(CompName, state.dataDXCoils->DXCoil);
+        if (DXCoilNum == 0) {
+            ShowFatalError(state, format("DX Coil not found={}", CompName));
+        }
+        CompIndex = DXCoilNum;
+    } else {
+        DXCoilNum = CompIndex;
+        if (DXCoilNum > state.dataDXCoils->NumDXCoils || DXCoilNum < 1) {
+            ShowFatalError(state,
+                           format("SimDXCoilMultiMode: Invalid CompIndex passed={}, Number of DX Coils={}, Coil name={}",
+                                  DXCoilNum,
+                                  state.dataDXCoils->NumDXCoils,
+                                  CompName));
+        }
+        if (state.dataDXCoils->CheckEquipName(DXCoilNum)) {
+            if ((CompName != "") && (CompName != state.dataDXCoils->DXCoil(DXCoilNum).Name)) {
+                ShowFatalError(state,
+                               format("SimDXCoilMultiMode: Invalid CompIndex passed={}, Coil name={}, stored Coil Name for that index={}",
+                                      DXCoilNum,
+                                      CompName,
+                                      state.dataDXCoils->DXCoil(DXCoilNum).Name));
+            }
+            state.dataDXCoils->CheckEquipName(DXCoilNum) = false;
+        }
+    }
+
+    SimDXCoilMultiMode(state,
+                       DXCoilNum,
+                       compressorOp,
+                       FirstHVACIteration,
+                       PartLoadRatio,
+                       DehumidMode,
+                       fanOp);
+}
+
+void SimDXCoilMultiMode(EnergyPlusData &state,
+                        int const coilNum,
+                        [[maybe_unused]] HVAC::CompressorOp const compressorOp, // compressor operation; 1=on, 0=off !unused1208
+                        bool const FirstHVACIteration,                          // true if first hvac iteration
+                        Real64 const PartLoadRatio,                             // part load ratio
+                        HVAC::CoilMode const DehumidMode,                       // dehumidification mode (0=normal, 1=enhanced)
+                        HVAC::FanOp const fanOp // allows parent object to control fan mode
+)
+{
     // SUBROUTINE INFORMATION:
     //       AUTHOR         M. J. Witte (based on SimDXCoilMultiSpeed by Fred Buhl)
     //       DATE WRITTEN   February 2005
@@ -385,13 +494,8 @@ void SimDXCoilMultiMode(EnergyPlusData &state,
     // Manages the simulation of a DX coil with multiple performance modes, such as
     // multiple stages, or sub-cool reheat for humidity control.
 
-    // Using/Aliasing
-
-    // SUBROUTINE PARAMETER DEFINITIONS:
     static constexpr std::string_view RoutineName("SimDXCoilMultiMode");
-
-    // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-    int DXCoilNum; // index of coil being simulated
+    
     int PerfMode;  // Performance mode for MultiMode DX coil; Always 1 for other coil types
     // 1-2=normal mode: 1=stage 1 only, 2=stage 1&2
     // 3-4=enhanced dehumidification mode: 3=stage 1 only, 4=stage 1&2
@@ -431,51 +535,17 @@ void SimDXCoilMultiMode(EnergyPlusData &state,
     Real64 TSat;      // calculation to avoid calling psych routines twice
     Real64 NodePress; // Pressure at condenser inlet node (Pa)
 
-    // First time SimDXCoil is called, get the input for all the DX coils (condensing units)
-    if (state.dataDXCoils->GetCoilsInputFlag) {
-        GetDXCoils(state);
-        state.dataDXCoils->GetCoilsInputFlag = false; // Set GetInputFlag false so you don't get coil inputs again
-    }
-
-    //  find correct DX Coil
-    if (CompIndex == 0) {
-        DXCoilNum = Util::FindItemInList(CompName, state.dataDXCoils->DXCoil);
-        if (DXCoilNum == 0) {
-            ShowFatalError(state, format("DX Coil not found={}", CompName));
-        }
-        CompIndex = DXCoilNum;
-    } else {
-        DXCoilNum = CompIndex;
-        if (DXCoilNum > state.dataDXCoils->NumDXCoils || DXCoilNum < 1) {
-            ShowFatalError(state,
-                           format("SimDXCoilMultiMode: Invalid CompIndex passed={}, Number of DX Coils={}, Coil name={}",
-                                  DXCoilNum,
-                                  state.dataDXCoils->NumDXCoils,
-                                  CompName));
-        }
-        if (state.dataDXCoils->CheckEquipName(DXCoilNum)) {
-            if ((CompName != "") && (CompName != state.dataDXCoils->DXCoil(DXCoilNum).Name)) {
-                ShowFatalError(state,
-                               format("SimDXCoilMultiMode: Invalid CompIndex passed={}, Coil name={}, stored Coil Name for that index={}",
-                                      DXCoilNum,
-                                      CompName,
-                                      state.dataDXCoils->DXCoil(DXCoilNum).Name));
-            }
-            state.dataDXCoils->CheckEquipName(DXCoilNum) = false;
-        }
-    }
-
     // Initialize the DX coil unit
-    InitDXCoil(state, DXCoilNum);
+    InitDXCoil(state, coilNum);
 
-    auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
     // Select the correct unit type
-    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+    if (dxCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
         // Initialize local variables
         S1RuntimeFraction = 0.0;
-        S1OutletAirEnthalpy = thisDXCoil.InletAirEnthalpy;
-        S1OutletAirHumRat = thisDXCoil.InletAirHumRat;
-        S1OutletAirTemp = thisDXCoil.InletAirTemp;
+        S1OutletAirEnthalpy = dxCoil.InletAirEnthalpy;
+        S1OutletAirHumRat = dxCoil.InletAirHumRat;
+        S1OutletAirTemp = dxCoil.InletAirTemp;
         S1ElecCoolingPower = 0.0;
         S1TotalCoolingEnergyRate = 0.0;
         S1SensCoolingEnergyRate = 0.0;
@@ -485,9 +555,9 @@ void SimDXCoilMultiMode(EnergyPlusData &state,
         S1EvapCondPumpElecPower = 0.0;
 
         S12RuntimeFraction = 0.0;
-        S12OutletAirEnthalpy = thisDXCoil.InletAirEnthalpy;
-        S12OutletAirHumRat = thisDXCoil.InletAirHumRat;
-        S12OutletAirTemp = thisDXCoil.InletAirTemp;
+        S12OutletAirEnthalpy = dxCoil.InletAirEnthalpy;
+        S12OutletAirHumRat = dxCoil.InletAirHumRat;
+        S12OutletAirTemp = dxCoil.InletAirTemp;
         S12ElecCoolingPower = 0.0;
         S12TotalCoolingEnergyRate = 0.0;
         S12SensCoolingEnergyRate = 0.0;
@@ -496,37 +566,37 @@ void SimDXCoilMultiMode(EnergyPlusData &state,
         S12EvapWaterConsumpRate = 0.0;
         S12EvapCondPumpElecPower = 0.0;
 
-        thisDXCoil.DehumidificationMode = DehumidMode;
-        if ((int)DehumidMode > thisDXCoil.NumDehumidModes) {
+        dxCoil.DehumidificationMode = DehumidMode;
+        if ((int)DehumidMode > dxCoil.NumDehumidModes) {
             ShowFatalError(state,
-                           format("{} \"{}\" - Requested enhanced dehumidification mode not available.", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                           format("{} \"{}\" - Requested enhanced dehumidification mode not available.", HVAC::coilTypeNamesUC[(int)dxCoil.coilType], dxCoil.Name));
         }
 
         // If a single-stage coil OR If part load is zero,
         // run stage 1 at zero part load to set leaving conditions
-        if ((thisDXCoil.NumCapacityStages == 1) || (PartLoadRatio <= 0.0)) {
+        if ((dxCoil.NumCapacityStages == 1) || (PartLoadRatio <= 0.0)) {
             // Run stage 1 at its part load
             PerfMode = (int)DehumidMode * 2 + 1; // This.  This is not good.  Don't do math on enums.
-            CalcDoe2DXCoil(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp, PerfMode);
+            CalcDoe2DXCoil(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadRatio, fanOp, PerfMode);
             S1PLR = PartLoadRatio;
             S2PLR = 0.0;
         } else {
             // If a two-stage coil
             // Run stage 1 at full load
             PerfMode = (int)DehumidMode * 2 + 1;
-            CalcDoe2DXCoil(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, 1.0, fanOp, PerfMode);
-            S1SensCoolingEnergyRate = thisDXCoil.SensCoolingEnergyRate;
+            CalcDoe2DXCoil(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, 1.0, fanOp, PerfMode);
+            S1SensCoolingEnergyRate = dxCoil.SensCoolingEnergyRate;
             if (S1SensCoolingEnergyRate > 0.0) {
                 S1PLR = PartLoadRatio;
             } else {
                 S1PLR = 0.0;
             }
             // Run stage 1+2 at full load
-            if (thisDXCoil.NumCapacityStages >= 2) {
+            if (dxCoil.NumCapacityStages >= 2) {
                 PerfMode = (int)DehumidMode * 2 + 2;
-                CalcDoe2DXCoil(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, 1.0, fanOp, PerfMode);
-                S12SensCoolingEnergyRate = thisDXCoil.SensCoolingEnergyRate;
-                S12ElecCoolFullLoadPower = thisDXCoil.ElecCoolingPower;
+                CalcDoe2DXCoil(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, 1.0, fanOp, PerfMode);
+                S12SensCoolingEnergyRate = dxCoil.SensCoolingEnergyRate;
+                S12ElecCoolFullLoadPower = dxCoil.ElecCoolingPower;
             }
 
             // Determine run-time fractions for each stage based on sensible capacities
@@ -556,70 +626,70 @@ void SimDXCoilMultiMode(EnergyPlusData &state,
 
             // Run stage 1 at its part load
             PerfMode = (int)DehumidMode * 2 + 1;
-            CalcDoe2DXCoil(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, S1PLR, fanOp, PerfMode);
+            CalcDoe2DXCoil(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, S1PLR, fanOp, PerfMode);
         }
         // For stage-1 only operation, all outputs are set by CalcDoe2DXCoil.
         // No further adjustments are necessary.
 
         // Run stage 2 if needed and available
-        if ((S2PLR > 0.0) && (thisDXCoil.NumCapacityStages >= 2)) {
+        if ((S2PLR > 0.0) && (dxCoil.NumCapacityStages >= 2)) {
             // Store stage 1 outputs
-            S1RuntimeFraction = thisDXCoil.CoolingCoilRuntimeFraction;
-            S1OutletAirEnthalpy = thisDXCoil.OutletAirEnthalpy;
-            S1OutletAirHumRat = thisDXCoil.OutletAirHumRat;
-            S1OutletAirTemp = thisDXCoil.OutletAirTemp;
-            S1ElecCoolingPower = thisDXCoil.ElecCoolingPower;
-            S1TotalCoolingEnergyRate = thisDXCoil.TotalCoolingEnergyRate;
-            S1SensCoolingEnergyRate = thisDXCoil.SensCoolingEnergyRate;
-            S1LatCoolingEnergyRate = thisDXCoil.LatCoolingEnergyRate;
-            S1CrankcaseHeaterPower = thisDXCoil.CrankcaseHeaterPower;
-            S1EvapWaterConsumpRate = thisDXCoil.EvapWaterConsumpRate;
-            S1EvapCondPumpElecPower = thisDXCoil.EvapCondPumpElecPower;
+            S1RuntimeFraction = dxCoil.CoolingCoilRuntimeFraction;
+            S1OutletAirEnthalpy = dxCoil.OutletAirEnthalpy;
+            S1OutletAirHumRat = dxCoil.OutletAirHumRat;
+            S1OutletAirTemp = dxCoil.OutletAirTemp;
+            S1ElecCoolingPower = dxCoil.ElecCoolingPower;
+            S1TotalCoolingEnergyRate = dxCoil.TotalCoolingEnergyRate;
+            S1SensCoolingEnergyRate = dxCoil.SensCoolingEnergyRate;
+            S1LatCoolingEnergyRate = dxCoil.LatCoolingEnergyRate;
+            S1CrankcaseHeaterPower = dxCoil.CrankcaseHeaterPower;
+            S1EvapWaterConsumpRate = dxCoil.EvapWaterConsumpRate;
+            S1EvapCondPumpElecPower = dxCoil.EvapCondPumpElecPower;
 
             // Save first stage full load outlet conditions to pass to heat recovery
-            S1FFullLoadOutAirTemp = state.dataDXCoils->DXCoilFullLoadOutAirTemp(DXCoilNum);
-            S1FullLoadOutAirHumRat = state.dataDXCoils->DXCoilFullLoadOutAirHumRat(DXCoilNum);
+            S1FFullLoadOutAirTemp = state.dataDXCoils->DXCoilFullLoadOutAirTemp(coilNum);
+            S1FullLoadOutAirHumRat = state.dataDXCoils->DXCoilFullLoadOutAirHumRat(coilNum);
 
             // Run stage 1+2 at its part load
             PerfMode = (int)DehumidMode * 2 + 2;
-            CalcDoe2DXCoil(state, DXCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, S2PLR, fanOp, PerfMode);
-            S12RuntimeFraction = thisDXCoil.CoolingCoilRuntimeFraction;
-            S12OutletAirEnthalpy = thisDXCoil.OutletAirEnthalpy;
-            S12OutletAirHumRat = thisDXCoil.OutletAirHumRat;
-            S12OutletAirTemp = thisDXCoil.OutletAirTemp;
-            S12ElecCoolingPower = thisDXCoil.ElecCoolingPower;
-            S12TotalCoolingEnergyRate = thisDXCoil.TotalCoolingEnergyRate;
-            S12SensCoolingEnergyRate = thisDXCoil.SensCoolingEnergyRate;
-            S12LatCoolingEnergyRate = thisDXCoil.LatCoolingEnergyRate;
-            S12CrankcaseHeaterPower = thisDXCoil.CrankcaseHeaterPower;
-            S12EvapWaterConsumpRate = thisDXCoil.EvapWaterConsumpRate;
-            S12EvapCondPumpElecPower = thisDXCoil.EvapCondPumpElecPower;
+            CalcDoe2DXCoil(state, coilNum, HVAC::CompressorOp::On, FirstHVACIteration, S2PLR, fanOp, PerfMode);
+            S12RuntimeFraction = dxCoil.CoolingCoilRuntimeFraction;
+            S12OutletAirEnthalpy = dxCoil.OutletAirEnthalpy;
+            S12OutletAirHumRat = dxCoil.OutletAirHumRat;
+            S12OutletAirTemp = dxCoil.OutletAirTemp;
+            S12ElecCoolingPower = dxCoil.ElecCoolingPower;
+            S12TotalCoolingEnergyRate = dxCoil.TotalCoolingEnergyRate;
+            S12SensCoolingEnergyRate = dxCoil.SensCoolingEnergyRate;
+            S12LatCoolingEnergyRate = dxCoil.LatCoolingEnergyRate;
+            S12CrankcaseHeaterPower = dxCoil.CrankcaseHeaterPower;
+            S12EvapWaterConsumpRate = dxCoil.EvapWaterConsumpRate;
+            S12EvapCondPumpElecPower = dxCoil.EvapCondPumpElecPower;
 
             // Determine combined performance
-            thisDXCoil.OutletAirEnthalpy = (1.0 - S2PLR) * S1OutletAirEnthalpy + S2PLR * S12OutletAirEnthalpy;
-            thisDXCoil.OutletAirHumRat = (1.0 - S2PLR) * S1OutletAirHumRat + S2PLR * S12OutletAirHumRat;
-            thisDXCoil.OutletAirTemp = PsyTdbFnHW(thisDXCoil.OutletAirEnthalpy, thisDXCoil.OutletAirHumRat);
+            dxCoil.OutletAirEnthalpy = (1.0 - S2PLR) * S1OutletAirEnthalpy + S2PLR * S12OutletAirEnthalpy;
+            dxCoil.OutletAirHumRat = (1.0 - S2PLR) * S1OutletAirHumRat + S2PLR * S12OutletAirHumRat;
+            dxCoil.OutletAirTemp = PsyTdbFnHW(dxCoil.OutletAirEnthalpy, dxCoil.OutletAirHumRat);
             // Check for saturation error and modify temperature at constant enthalpy
-            if (thisDXCoil.CondenserInletNodeNum(PerfMode) != 0) {
-                NodePress = state.dataLoopNodes->Node(thisDXCoil.CondenserInletNodeNum(PerfMode)).Press;
+            if (dxCoil.CondenserInletNodeNum(PerfMode) != 0) {
+                NodePress = state.dataLoopNodes->Node(dxCoil.CondenserInletNodeNum(PerfMode)).Press;
                 // If node is not connected to anything, pressure = default, use weather data
                 if (NodePress == state.dataLoopNodes->DefaultNodeValues.Press) NodePress = state.dataEnvrn->OutBaroPress;
-                TSat = PsyTsatFnHPb(state, thisDXCoil.OutletAirEnthalpy, NodePress, RoutineName);
-                if (thisDXCoil.OutletAirTemp < TSat) {
-                    thisDXCoil.OutletAirTemp = TSat;
+                TSat = PsyTsatFnHPb(state, dxCoil.OutletAirEnthalpy, NodePress, RoutineName);
+                if (dxCoil.OutletAirTemp < TSat) {
+                    dxCoil.OutletAirTemp = TSat;
                 }
-                thisDXCoil.OutletAirHumRat = PsyWFnTdbH(state, thisDXCoil.OutletAirTemp, thisDXCoil.OutletAirEnthalpy, RoutineName);
+                dxCoil.OutletAirHumRat = PsyWFnTdbH(state, dxCoil.OutletAirTemp, dxCoil.OutletAirEnthalpy, RoutineName);
             } else {
-                TSat = PsyTsatFnHPb(state, thisDXCoil.OutletAirEnthalpy, state.dataEnvrn->OutBaroPress, RoutineName);
-                if (thisDXCoil.OutletAirTemp < TSat) {
-                    thisDXCoil.OutletAirTemp = TSat;
+                TSat = PsyTsatFnHPb(state, dxCoil.OutletAirEnthalpy, state.dataEnvrn->OutBaroPress, RoutineName);
+                if (dxCoil.OutletAirTemp < TSat) {
+                    dxCoil.OutletAirTemp = TSat;
                 }
                 //  Eventually inlet air conditions will be used in DX Coil, these lines are commented out and marked with this comment line
                 //      IF(DXCoil(DXCoilNum)%OutletAirTemp .LT. PsyTsatFnHPb(DXCoil(DXCoilNum)%OutletAirEnthalpy, &
                 //                 Node(DXCoil(DXCoilNum)%AirInNode)%Press)) THEN
                 //        DXCoil(DXCoilNum)%OutletAirTemp = PsyTsatFnHPb(DXCoil(DXCoilNum)%OutletAirEnthalpy, &
                 //                 Node(DXCoil(DXCoilNum)%AirInNode)%Press)
-                thisDXCoil.OutletAirHumRat = PsyWFnTdbH(state, thisDXCoil.OutletAirTemp, thisDXCoil.OutletAirEnthalpy, RoutineName);
+                dxCoil.OutletAirHumRat = PsyWFnTdbH(state, dxCoil.OutletAirTemp, dxCoil.OutletAirEnthalpy, RoutineName);
             }
 
             //      DXCoil(DXCoilNum)%ElecCoolingPower = (1-S12RuntimeFraction)*S1ElecCoolingPower &
@@ -628,64 +698,64 @@ void SimDXCoilMultiMode(EnergyPlusData &state,
             //  So, must make an adjustment for S12ElecCoolingPower/S12ElecCoolFullLoadPower
             //  when subtracting off S1ElecCoolingPower
             if (S12ElecCoolFullLoadPower > 0.0) {
-                thisDXCoil.ElecCoolingPower =
+                dxCoil.ElecCoolingPower =
                     S1RuntimeFraction * S1ElecCoolingPower +
                     S12RuntimeFraction * (S12ElecCoolingPower - S1ElecCoolingPower * S12ElecCoolingPower / S12ElecCoolFullLoadPower);
             } else {
-                thisDXCoil.ElecCoolingPower = 0.0;
+                dxCoil.ElecCoolingPower = 0.0;
             }
 
-            thisDXCoil.CoolingCoilRuntimeFraction = S1RuntimeFraction;
+            dxCoil.CoolingCoilRuntimeFraction = S1RuntimeFraction;
 
-            AirMassFlow = thisDXCoil.InletAirMassFlowRate;
+            AirMassFlow = dxCoil.InletAirMassFlowRate;
             CalcComponentSensibleLatentOutput(AirMassFlow,
-                                              thisDXCoil.InletAirTemp,
-                                              thisDXCoil.InletAirHumRat,
-                                              thisDXCoil.OutletAirTemp,
-                                              thisDXCoil.OutletAirHumRat,
-                                              thisDXCoil.SensCoolingEnergyRate,
-                                              thisDXCoil.LatCoolingEnergyRate,
-                                              thisDXCoil.TotalCoolingEnergyRate);
+                                              dxCoil.InletAirTemp,
+                                              dxCoil.InletAirHumRat,
+                                              dxCoil.OutletAirTemp,
+                                              dxCoil.OutletAirHumRat,
+                                              dxCoil.SensCoolingEnergyRate,
+                                              dxCoil.LatCoolingEnergyRate,
+                                              dxCoil.TotalCoolingEnergyRate);
 
-            thisDXCoil.EvapWaterConsumpRate = (1.0 - S12RuntimeFraction) * S1EvapWaterConsumpRate + S12RuntimeFraction * S12EvapWaterConsumpRate;
-            thisDXCoil.EvapCondPumpElecPower = (1.0 - S12RuntimeFraction) * S1EvapCondPumpElecPower + S12RuntimeFraction * S12EvapCondPumpElecPower;
+            dxCoil.EvapWaterConsumpRate = (1.0 - S12RuntimeFraction) * S1EvapWaterConsumpRate + S12RuntimeFraction * S12EvapWaterConsumpRate;
+            dxCoil.EvapCondPumpElecPower = (1.0 - S12RuntimeFraction) * S1EvapCondPumpElecPower + S12RuntimeFraction * S12EvapCondPumpElecPower;
 
             // Stage 1 runtime sets the crankcase heater power
-            thisDXCoil.CrankcaseHeaterPower = S1CrankcaseHeaterPower;
+            dxCoil.CrankcaseHeaterPower = S1CrankcaseHeaterPower;
 
-            state.dataDXCoils->DXCoilOutletTemp(DXCoilNum) = thisDXCoil.OutletAirTemp;
-            state.dataDXCoils->DXCoilOutletHumRat(DXCoilNum) = thisDXCoil.OutletAirHumRat;
+            state.dataDXCoils->DXCoilOutletTemp(coilNum) = dxCoil.OutletAirTemp;
+            state.dataDXCoils->DXCoilOutletHumRat(coilNum) = dxCoil.OutletAirHumRat;
 
             //     calculate average full load outlet conditions for second stage operation
-            state.dataDXCoils->DXCoilFullLoadOutAirTemp(DXCoilNum) =
-                (1.0 - S2PLR) * S1FFullLoadOutAirTemp + S2PLR * state.dataDXCoils->DXCoilFullLoadOutAirTemp(DXCoilNum);
-            state.dataDXCoils->DXCoilFullLoadOutAirHumRat(DXCoilNum) =
-                (1.0 - S2PLR) * S1FullLoadOutAirHumRat + S2PLR * state.dataDXCoils->DXCoilFullLoadOutAirHumRat(DXCoilNum);
+            state.dataDXCoils->DXCoilFullLoadOutAirTemp(coilNum) =
+                (1.0 - S2PLR) * S1FFullLoadOutAirTemp + S2PLR * state.dataDXCoils->DXCoilFullLoadOutAirTemp(coilNum);
+            state.dataDXCoils->DXCoilFullLoadOutAirHumRat(coilNum) =
+                (1.0 - S2PLR) * S1FullLoadOutAirHumRat + S2PLR * state.dataDXCoils->DXCoilFullLoadOutAirHumRat(coilNum);
 
         } // End if stage 2 is operating
 
         //   set the part load ratio and heat reclaim capacity for use by desuperheater heating coils
-        thisDXCoil.PartLoadRatio = S1PLR;
-        state.dataDXCoils->DXCoilPartLoadRatio(DXCoilNum) = S1PLR;
+        dxCoil.PartLoadRatio = S1PLR;
+        state.dataDXCoils->DXCoilPartLoadRatio(coilNum) = S1PLR;
 
         //   Calculation for heat reclaim needs to be corrected to use compressor power (not including condenser fan power)
-        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).AvailCapacity = thisDXCoil.TotalCoolingEnergyRate + thisDXCoil.ElecCoolingPower;
+        state.dataHeatBal->HeatReclaimDXCoil(coilNum).AvailCapacity = dxCoil.TotalCoolingEnergyRate + dxCoil.ElecCoolingPower;
 
-        thisDXCoil.CoolingCoilStg2RuntimeFrac = S12RuntimeFraction;
+        dxCoil.CoolingCoilStg2RuntimeFrac = S12RuntimeFraction;
 
         //   Calculate basin heater power
-        CalcBasinHeaterPowerForMultiModeDXCoil(state, DXCoilNum, DehumidMode);
+        CalcBasinHeaterPowerForMultiModeDXCoil(state, coilNum, DehumidMode);
     } else {
-        ShowSevereError(state, format("Error detected in DX Coil={}", CompName));
-        ShowContinueError(state, format("Invalid DX Coil Type={}", thisDXCoil.DXCoilType));
+        ShowSevereError(state, format("Error detected in DX Coil={}", dxCoil.Name));
+        ShowContinueError(state, format("Invalid DX Coil Type={}", HVAC::coilTypeNamesUC[(int)dxCoil.coilType]));
         ShowFatalError(state, "Preceding condition causes termination.");
     }
 
     // Update the unit outlet nodes
-    UpdateDXCoil(state, DXCoilNum);
+    UpdateDXCoil(state, coilNum);
 
     // Report the result of the simulation
-    ReportDXCoil(state, DXCoilNum);
+    ReportDXCoil(state, coilNum);
 }
 
 void GetDXCoils(EnergyPlusData &state)
@@ -778,19 +848,19 @@ void GetDXCoils(EnergyPlusData &state)
     state.dataDXCoils->NumDXMulModeCoils =
         state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Coil:Cooling:DX:TwoStageWithHumidityControlMode");
     state.dataDXCoils->NumDXHeatPumpWaterHeaterPumpedCoils =
-        state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterPumped));
+      state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::coilTypeNames[(int)HVAC::CoilType::WaterHeatingDXPumped]);
     state.dataDXCoils->NumDXHeatPumpWaterHeaterWrappedCoils =
-        state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterWrapped));
+      state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::coilTypeNames[(int)HVAC::CoilType::WaterHeatingDXWrapped]);
     state.dataDXCoils->NumDXMulSpeedCoolCoils = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Coil:Cooling:DX:MultiSpeed");
     state.dataDXCoils->NumDXMulSpeedHeatCoils = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Coil:Heating:DX:MultiSpeed");
     state.dataDXCoils->NumVRFCoolingCoils =
-        state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Cooling));
+      state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingVRF]);
     state.dataDXCoils->NumVRFHeatingCoils =
-        state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Heating));
+      state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingVRF]);
     state.dataDXCoils->NumVRFCoolingFluidTCtrlCoils =
-        state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Cooling));
+      state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingVRFFluidTCtrl]);
     state.dataDXCoils->NumVRFHeatingFluidTCtrlCoils =
-        state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Heating));
+      state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingVRFFluidTCtrl]);
 
     state.dataDXCoils->NumDXCoils = state.dataDXCoils->NumDoe2DXCoils + state.dataDXCoils->NumDXHeatingCoils + state.dataDXCoils->NumDXMulSpeedCoils +
                                     state.dataDXCoils->NumDXMulModeCoils + state.dataDXCoils->NumDXHeatPumpWaterHeaterPumpedCoils +
@@ -814,11 +884,11 @@ void GetDXCoils(EnergyPlusData &state)
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-        state, HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterPumped), TotalArgs, NumAlphas, NumNumbers);
+        state, HVAC::coilTypeNames[(int)HVAC::CoilType::WaterHeatingDXPumped], TotalArgs, NumAlphas, NumNumbers);
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-        state, HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterWrapped), TotalArgs, NumAlphas, NumNumbers);
+        state, HVAC::coilTypeNames[(int)HVAC::CoilType::WaterHeatingDXWrapped], TotalArgs, NumAlphas, NumNumbers);
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "Coil:Cooling:DX:MultiSpeed", TotalArgs, NumAlphas, NumNumbers);
@@ -828,19 +898,19 @@ void GetDXCoils(EnergyPlusData &state)
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-        state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Cooling), TotalArgs, NumAlphas, NumNumbers);
+        state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingVRF], TotalArgs, NumAlphas, NumNumbers);
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-        state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Heating), TotalArgs, NumAlphas, NumNumbers);
+        state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingVRF], TotalArgs, NumAlphas, NumNumbers);
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-        state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Cooling), TotalArgs, NumAlphas, NumNumbers);
+        state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingVRFFluidTCtrl], TotalArgs, NumAlphas, NumNumbers);
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-        state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Heating), TotalArgs, NumAlphas, NumNumbers);
+        state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingVRFFluidTCtrl], TotalArgs, NumAlphas, NumNumbers);
     MaxNumbers = max(MaxNumbers, NumNumbers);
     MaxAlphas = max(MaxAlphas, NumAlphas);
     state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "CoilPerformance:DX:Cooling", TotalArgs, NumAlphas, NumNumbers);
@@ -924,9 +994,10 @@ void GetDXCoils(EnergyPlusData &state)
         thisDXCoil.Name = Alphas(1);
         // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
         state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).Name = thisDXCoil.Name;
-        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = CurrentModuleObject;
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
+
+        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed];
+        thisDXCoil.coilType = HVAC::CoilType::CoolingDXSingleSpeed;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -1408,9 +1479,10 @@ void GetDXCoils(EnergyPlusData &state)
         thisDXCoil.Name = Alphas(1);
         // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
         state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).Name = thisDXCoil.Name;
-        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = CurrentModuleObject;
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_CoolingTwoStageWHumControl;
+
+        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXTwoStageWHumControl];
+        thisDXCoil.coilType = HVAC::CoilType::CoolingDXTwoStageWHumControl;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -1507,16 +1579,15 @@ void GetDXCoils(EnergyPlusData &state)
                     PerfObjectType = Alphas(AlphaIndex);
                     PerfObjectName = Alphas(AlphaIndex + 1);
                     PerfModeNum = DehumidModeNum * 2 + CapacityStageNum;
-                    thisDXCoil.CoilPerformanceType(PerfModeNum) = PerfObjectType;
                     if (Util::SameString(PerfObjectType, "CoilPerformance:DX:Cooling")) {
-                        thisDXCoil.CoilPerformanceType_Num(PerfModeNum) = HVAC::CoilPerfDX_CoolBypassEmpirical;
+                        thisDXCoil.coilPerformanceTypes(PerfModeNum) = HVAC::CoilType::CoolingDX;
                     } else {
                         ShowSevereError(state, format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, thisDXCoil.Name));
                         ShowContinueError(state, format("...illegal {}=\"{}\".", cAlphaFields(AlphaIndex), PerfObjectType));
                         ShowContinueError(state, "Must be \"CoilPerformance:DX:Cooling\".");
                         ErrorsFound = true;
                     }
-                    thisDXCoil.CoilPerformanceName(PerfModeNum) = PerfObjectName;
+                    thisDXCoil.coilPerformanceNames(PerfModeNum) = PerfObjectName;
                     // Get for CoilPerformance object
                     PerfObjectNum = state.dataInputProcessing->inputProcessor->getObjectItemNum(state, PerfObjectType, PerfObjectName);
                     if (PerfObjectNum > 0) {
@@ -1969,8 +2040,9 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
         thisDXCoil.Name = Alphas(1);
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+
+        thisDXCoil.coilType = HVAC::CoilType::HeatingDXSingleSpeed;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -2437,9 +2509,10 @@ void GetDXCoils(EnergyPlusData &state)
         thisDXCoil.Name = Alphas(1);
         // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
         state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).Name = thisDXCoil.Name;
-        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = CurrentModuleObject;
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_CoolingTwoSpeed;
+
+        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXTwoSpeed]; 
+        thisDXCoil.coilType = HVAC::CoilType::CoolingDXTwoSpeed;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -2978,7 +3051,7 @@ void GetDXCoils(EnergyPlusData &state)
     }
 
     // Loop over the Pumped DX Water Heater Coils and get & load the data
-    CurrentModuleObject = HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterPumped);
+    CurrentModuleObject = HVAC::coilTypeNames[(int)HVAC::CoilType::WaterHeatingDXPumped];
     for (DXHPWaterHeaterCoilNum = 1; DXHPWaterHeaterCoilNum <= state.dataDXCoils->NumDXHeatPumpWaterHeaterPumpedCoils; ++DXHPWaterHeaterCoilNum) {
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -3005,8 +3078,8 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
         thisDXCoil.Name = Alphas(1);
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_HeatPumpWaterHeaterPumped;
+
+        thisDXCoil.coilType = HVAC::CoilType::WaterHeatingDXPumped;
         thisDXCoil.availSched = Sched::GetScheduleAlwaysOff(state); // heat pump water heater DX coil has no schedule
 
         // Store the HPWH DX coil heating capacity in RatedTotCap2. After backing off pump and fan heat,
@@ -3476,7 +3549,7 @@ void GetDXCoils(EnergyPlusData &state)
                        format("{}Errors found in getting {} input. Preceding condition(s) causes termination.", RoutineName, CurrentModuleObject));
     }
     // Loop over the Wrapped DX Water Heater Coils and get & load the data
-    CurrentModuleObject = HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterWrapped);
+    CurrentModuleObject = HVAC::coilTypeNames[(int)HVAC::CoilType::WaterHeatingDXWrapped];
     for (DXHPWaterHeaterCoilNum = 1; DXHPWaterHeaterCoilNum <= state.dataDXCoils->NumDXHeatPumpWaterHeaterWrappedCoils; ++DXHPWaterHeaterCoilNum) {
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -3503,8 +3576,9 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
         thisDXCoil.Name = Alphas(1);
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_HeatPumpWaterHeaterWrapped;
+
+        thisDXCoil.coilType = HVAC::CoilType::WaterHeatingDXWrapped;
+
         thisDXCoil.availSched = Sched::GetScheduleAlwaysOff(state); // heat pump water heater DX coil has no schedule
 
         // Store the HPWH DX coil heating capacity in RatedTotCap2. After backing off pump and fan heat,
@@ -3905,9 +3979,10 @@ void GetDXCoils(EnergyPlusData &state)
         thisDXCoil.Name = Alphas(1);
         // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
         state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).Name = thisDXCoil.Name;
-        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = CurrentModuleObject;
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
+
+        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXMultiSpeed];
+        thisDXCoil.coilType = HVAC::CoilType::CoolingDXMultiSpeed;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -4455,9 +4530,10 @@ void GetDXCoils(EnergyPlusData &state)
         thisDXCoil.Name = Alphas(1);
         // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
         state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).Name = thisDXCoil.Name;
-        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = CurrentModuleObject;
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilDX_MultiSpeedHeating;
+
+        state.dataHeatBal->HeatReclaimDXCoil(DXCoilNum).SourceType = HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingDXMultiSpeed]; 
+        thisDXCoil.coilType = HVAC::CoilType::HeatingDXMultiSpeed;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -4919,7 +4995,7 @@ void GetDXCoils(EnergyPlusData &state)
     }
 
     // Loop over the VRF Cooling Coils and get & load the data
-    CurrentModuleObject = HVAC::cAllCoilTypes(HVAC::CoilVRF_Cooling);
+    CurrentModuleObject = HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingVRF];
     for (DXCoilIndex = 1; DXCoilIndex <= state.dataDXCoils->NumVRFCoolingCoils; ++DXCoilIndex) {
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -4948,8 +5024,8 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
         thisDXCoil.Name = Alphas(1);
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilVRF_Cooling;
+
+        thisDXCoil.coilType = HVAC::CoilType::CoolingVRF;
 
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
@@ -5061,7 +5137,7 @@ void GetDXCoils(EnergyPlusData &state)
     }
 
     // Loop over the VRF Heating Coils and get & load the data
-    CurrentModuleObject = HVAC::cAllCoilTypes(HVAC::CoilVRF_Heating);
+    CurrentModuleObject = HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingVRF];
     for (DXCoilIndex = 1; DXCoilIndex <= state.dataDXCoils->NumVRFHeatingCoils; ++DXCoilIndex) {
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -5089,8 +5165,8 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
         thisDXCoil.Name = Alphas(1);
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilVRF_Heating;
+        thisDXCoil.coilType = HVAC::CoilType::HeatingVRF;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -5190,7 +5266,7 @@ void GetDXCoils(EnergyPlusData &state)
     }
 
     // Loop over the VRF Cooling Coils for VRF FluidTCtrl Model_zrp 2015
-    CurrentModuleObject = HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Cooling);
+    CurrentModuleObject = HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingVRFFluidTCtrl];
     for (DXCoilIndex = 1; DXCoilIndex <= state.dataDXCoils->NumVRFCoolingFluidTCtrlCoils; ++DXCoilIndex) {
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -5218,8 +5294,9 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
         thisDXCoil.Name = Alphas(1);
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilVRF_FluidTCtrl_Cooling;
+
+        thisDXCoil.coilType = HVAC::CoilType::CoolingVRFFluidTCtrl;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -5304,7 +5381,7 @@ void GetDXCoils(EnergyPlusData &state)
     }
 
     // Loop over the VRF Heating Coils for VRF FluidTCtrl Model_zrp 2015
-    CurrentModuleObject = HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Heating);
+    CurrentModuleObject = HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingVRFFluidTCtrl];
     for (DXCoilIndex = 1; DXCoilIndex <= state.dataDXCoils->NumVRFHeatingFluidTCtrlCoils; ++DXCoilIndex) {
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -5332,8 +5409,9 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
         thisDXCoil.Name = Alphas(1);
-        thisDXCoil.DXCoilType = CurrentModuleObject;
-        thisDXCoil.DXCoilType_Num = HVAC::CoilVRF_FluidTCtrl_Heating;
+
+        thisDXCoil.coilType = HVAC::CoilType::HeatingVRFFluidTCtrl;
+
         if (lAlphaBlanks(2)) {
             thisDXCoil.availSched = Sched::GetScheduleAlwaysOn(state);
         } else if ((thisDXCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
@@ -5405,7 +5483,8 @@ void GetDXCoils(EnergyPlusData &state)
 
         auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
 
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+        if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+            thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
             // Setup Report Variables for Cooling Equipment
             // CurrentModuleObject='Coil:Cooling:DX:SingleSpeed/Coil:Cooling:DX:TwoStageWithHumidityControlMode'
             SetupOutputVariable(state,
@@ -5574,7 +5653,7 @@ void GetDXCoils(EnergyPlusData &state)
                 }
             }
 
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                 // Setup Report Variables for Cooling Equipment
                 // CurrentModuleObject='Cooling:DX:TwoStageWithHumidityControlMode'
                 SetupOutputVariable(state,
@@ -5595,7 +5674,7 @@ void GetDXCoils(EnergyPlusData &state)
 
         }
 
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed) {
             // Setup Report Variables for Heating Equipment
             // CurrentModuleObject='Coil:Heating:DX:SingleSpeed'
             SetupOutputVariable(state,
@@ -5712,7 +5791,7 @@ void GetDXCoils(EnergyPlusData &state)
             }
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
-                                 thisDXCoil.DXCoilType,
+                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                  thisDXCoil.Name,
                                  "Frost Heating Capacity Multiplier",
                                  "[]",
@@ -5720,7 +5799,7 @@ void GetDXCoils(EnergyPlusData &state)
                                  thisDXCoil.FrostHeatingCapacityMultiplierEMSOverrideValue);
 
                 SetupEMSActuator(state,
-                                 thisDXCoil.DXCoilType,
+                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                  thisDXCoil.Name,
                                  "Frost Heating Input Power Multiplier",
                                  "[]",
@@ -5729,7 +5808,7 @@ void GetDXCoils(EnergyPlusData &state)
             }
         }
 
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
             // Setup Report Variables for Cooling Equipment
             // CurrentModuleObject='Coil:Cooling:DX:TwoSpeed'
             SetupOutputVariable(state,
@@ -5879,8 +5958,8 @@ void GetDXCoils(EnergyPlusData &state)
 
         }
 
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                 thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                 thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
             // Setup Report Variables for Cooling Equipment
             // CurrentModuleObject='Coil:WaterHeating:AirToWaterHeatPump:Pumped'
             // or 'Coil:WaterHeating:AirToWaterHeatPump:Wrapped'
@@ -6004,7 +6083,7 @@ void GetDXCoils(EnergyPlusData &state)
                                 OutputProcessor::EndUseCat::WaterSystem); // DHW
         }
 
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed) {
             // Setup Report Variables for Cooling Equipment:
             // CurrentModuleObject='Coil:Cooling:DX:MultiSpeed'
             SetupOutputVariable(state,
@@ -6176,7 +6255,7 @@ void GetDXCoils(EnergyPlusData &state)
 
         }
 
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
             // Setup Report Variables for Heating Equipment:
             // CurrentModuleObject='Coil:Heating:DX:MultiSpeed'
             SetupOutputVariable(state,
@@ -6332,7 +6411,7 @@ void GetDXCoils(EnergyPlusData &state)
 
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
-                                 thisDXCoil.DXCoilType,
+                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                  thisDXCoil.Name,
                                  "Frost Heating Capacity Multiplier",
                                  "[]",
@@ -6340,7 +6419,7 @@ void GetDXCoils(EnergyPlusData &state)
                                  thisDXCoil.FrostHeatingCapacityMultiplierEMSOverrideValue);
 
                 SetupEMSActuator(state,
-                                 thisDXCoil.DXCoilType,
+                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                  thisDXCoil.Name,
                                  "Frost Heating Input Power Multiplier",
                                  "[]",
@@ -6350,7 +6429,7 @@ void GetDXCoils(EnergyPlusData &state)
         }
 
         // VRF cooling coil report variables
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Cooling) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::CoolingVRF) {
             // Setup Report Variables for Cooling Equipment:
             // CurrentModuleObject='Coil:Cooling:DX:VariableRefrigerantFlow
             SetupOutputVariable(state,
@@ -6427,7 +6506,7 @@ void GetDXCoils(EnergyPlusData &state)
         }
 
         // VRF heating coil report variables
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::HeatingVRF) {
             // Setup Report Variables for Heating Equipment:
             // CurrentModuleObject='Coil:Heating:DX:VariableRefrigerantFlow
             SetupOutputVariable(state,
@@ -6457,7 +6536,7 @@ void GetDXCoils(EnergyPlusData &state)
 
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
-                                 thisDXCoil.DXCoilType,
+                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                  thisDXCoil.Name,
                                  "Frost Heating Capacity Multiplier",
                                  "[]",
@@ -6465,7 +6544,7 @@ void GetDXCoils(EnergyPlusData &state)
                                  thisDXCoil.FrostHeatingCapacityMultiplierEMSOverrideValue);
 
                 SetupEMSActuator(state,
-                                 thisDXCoil.DXCoilType,
+                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                  thisDXCoil.Name,
                                  "Frost Heating Input Power Multiplier",
                                  "[]",
@@ -6475,7 +6554,7 @@ void GetDXCoils(EnergyPlusData &state)
         }
 
         // VRF cooling coil for FluidTCtrl, report variables
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
             // Setup Report Variables for Cooling Equipment:
             // CurrentModuleObject='Coil:Cooling:DX:VariableRefrigerantFlow:FluidTemperatureControl
             SetupOutputVariable(state,
@@ -6568,7 +6647,7 @@ void GetDXCoils(EnergyPlusData &state)
         }
 
         // VRF heating coil for FluidTCtrl, report variables
-        else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Heating) {
+        else if (thisDXCoil.coilType == HVAC::CoilType::HeatingVRFFluidTCtrl) {
             // Setup Report Variables for Heating Equipment:
             // CurrentModuleObject='Coil:Heating:DX:VariableRefrigerantFlow:FluidTemperatureControl
             SetupOutputVariable(state,
@@ -6707,8 +6786,8 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
     // if "ISHundredPercentDOASDXCoil" =.TRUE., then set coil as 100% DOAS dx coil
     state.dataHVACGlobal->DXCT = (thisDXCoil.ISHundredPercentDOASDXCoil) ? HVAC::DXCoilType::DOAS : HVAC::DXCoilType::Regular;
 
-    if ((thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-         thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) &&
+    if ((thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+         thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) &&
         state.dataDXCoils->MyEnvrnFlag(DXCoilNum)) {
 
         SizeDXCoil(state, DXCoilNum);
@@ -6718,7 +6797,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             ((RatedVolFlowPerRatedTotCap - HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) > SmallDifferenceTest)) {
             ShowWarningError(state,
                              format("{} \"{}\": Rated air volume flow rate per watt of rated total water heating capacity is out of range",
-                                    thisDXCoil.DXCoilType,
+                                    HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                     thisDXCoil.Name));
             ShowContinueError(state,
                               format("Min Rated Vol Flow Per Watt=[{:.3T}], Rated Vol Flow Per Watt=[{:.3T}], Max Rated Vol Flow Per "
@@ -6744,7 +6823,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         }
 
         thisDXCoil.RatedCBF(1) = CalcCBF(state,
-                                         thisDXCoil.DXCoilType,
+                                         thisDXCoil.coilType,
                                          thisDXCoil.Name,
                                          thisDXCoil.RatedInletDBTemp,
                                          HPInletAirHumRat,
@@ -6755,7 +6834,8 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         state.dataDXCoils->MyEnvrnFlag(DXCoilNum) = false;
     }
 
-    if ((thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) &&
+    if ((thisDXCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+         thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) &&
         state.dataDXCoils->MyEnvrnFlag(DXCoilNum)) {
         if (thisDXCoil.FuelType != Constant::eFuel::Electricity) {
             if (thisDXCoil.MSHPHeatRecActive) {
@@ -6775,8 +6855,8 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
 
     // Find the companion upstream coil (DX cooling coil) that is used with DX heating coils (HP AC units only)
     if (thisDXCoil.FindCompanionUpStreamCoil) {
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
-            thisDXCoil.CompanionUpstreamDXCoil = GetHPCoolingCoilIndex(state, thisDXCoil.DXCoilType, thisDXCoil.Name, DXCoilNum);
+      if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed || thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+            thisDXCoil.CompanionUpstreamDXCoil = GetHPCoolingCoilIndex(state, DXCoilNum);
             if (thisDXCoil.CompanionUpstreamDXCoil > 0) {
                 state.dataDXCoils->DXCoil(thisDXCoil.CompanionUpstreamDXCoil).ReportCoolingCoilCrankcasePower = false;
                 thisDXCoil.FindCompanionUpStreamCoil = false;
@@ -6796,9 +6876,9 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         if (state.dataAirLoop->AirLoopInputsFilled) {
             //     Set report variables for DX cooling coils that will have a crankcase heater (all DX coils not used in a HP AC unit)
             for (DXCoilNumTemp = 1; DXCoilNumTemp <= state.dataDXCoils->NumDXCoils; ++DXCoilNumTemp) {
-                if ((state.dataDXCoils->DXCoil(DXCoilNumTemp).DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) ||
-                    (state.dataDXCoils->DXCoil(DXCoilNumTemp).DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) ||
-                    (state.dataDXCoils->DXCoil(DXCoilNumTemp).DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling)) {
+                if ((state.dataDXCoils->DXCoil(DXCoilNumTemp).coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) ||
+                    (state.dataDXCoils->DXCoil(DXCoilNumTemp).coilType == HVAC::CoilType::CoolingDXSingleSpeed) ||
+                    (state.dataDXCoils->DXCoil(DXCoilNumTemp).coilType == HVAC::CoilType::CoolingDXMultiSpeed)) {
                     if (state.dataDXCoils->DXCoil(DXCoilNumTemp).ReportCoolingCoilCrankcasePower) {
                         SetupOutputVariable(state,
                                             "Cooling Coil Crankcase Heater Electricity Rate",
@@ -6830,17 +6910,19 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         SizeDXCoil(state, DXCoilNum);
         state.dataDXCoils->MySizeFlag(DXCoilNum) = false;
 
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-            thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Cooling || thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
+        if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+            thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+            thisDXCoil.coilType == HVAC::CoilType::CoolingVRF ||
+            thisDXCoil.coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
 
             Mode = 1;
             // Check for zero capacity or zero max flow rate
             if (thisDXCoil.RatedTotCap(Mode) <= 0.0) {
-                ShowSevereError(state, format("Sizing: {} {} has zero rated total capacity", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                ShowSevereError(state, format("Sizing: {} {} has zero rated total capacity", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                 ErrorsFound = true;
             }
             if (thisDXCoil.RatedAirVolFlowRate(Mode) <= 0.0) {
-                ShowSevereError(state, format("Sizing: {} {} has zero rated air flow rate", thisDXCoil.DXCoilType, thisDXCoil.Name));
+              ShowSevereError(state, format("Sizing: {} {} has zero rated air flow rate", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                 ErrorsFound = true;
             }
             if (ErrorsFound) {
@@ -6848,14 +6930,14 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             }
 
             // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
-            if (thisDXCoil.DXCoilType_Num !=
-                HVAC::CoilVRF_FluidTCtrl_Cooling) { // the VolFlowPerRatedTotCap check is not applicable for VRF-FluidTCtrl coil
+            // the VolFlowPerRatedTotCap check is not applicable for VRF-FluidTCtrl coil
+            if (thisDXCoil.coilType != HVAC::CoilType::CoolingVRFFluidTCtrl) { 
                 RatedVolFlowPerRatedTotCap = thisDXCoil.RatedAirVolFlowRate(Mode) / thisDXCoil.RatedTotCap(Mode);
                 if (((HVAC::MinRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT] - RatedVolFlowPerRatedTotCap) > SmallDifferenceTest) ||
                     ((RatedVolFlowPerRatedTotCap - HVAC::MaxRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) > SmallDifferenceTest)) {
                     ShowWarningError(state,
                                      format("Sizing: {} \"{}\": Rated air volume flow rate per watt of rated total cooling capacity is out of range.",
-                                            thisDXCoil.DXCoilType,
+                                            HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                             thisDXCoil.Name));
                     ShowContinueError(state,
                                       format("Min Rated Vol Flow Per Watt=[{:.3T}], Rated Vol Flow Per Watt=[{:.3T}], Max Rated Vol Flow Per "
@@ -6871,7 +6953,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
                 PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
             // get high speed rated coil bypass factor
             thisDXCoil.RatedCBF(Mode) = CalcCBF(state,
-                                                thisDXCoil.DXCoilType,
+                                                thisDXCoil.coilType,
                                                 thisDXCoil.Name,
                                                 RatedInletAirTemp,
                                                 RatedInletAirHumRat,
@@ -6909,13 +6991,13 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             }
 
             // calculate coil model at rating point
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                 CalcDoe2DXCoil(state, DXCoilNum, HVAC::CompressorOp::On, false, 1.0, HVAC::FanOp::Cycling, _, 1.0);
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 CalcMultiSpeedDXCoil(state, DXCoilNum, 1.0, 1.0);
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Cooling) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingVRF) {
                 CalcVRFCoolingCoil(state, DXCoilNum, HVAC::CompressorOp::On, false, 1.0, HVAC::FanOp::Cycling, 1.0, _, _, _);
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
                 CalcVRFCoolingCoil_FluidTCtrl(
                     state, DXCoilNum, HVAC::CompressorOp::On, false, 1.0, HVAC::FanOp::Cycling, 1.0, _, _, Constant::MaxCap);
             }
@@ -6925,10 +7007,10 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
                 state, thisDXCoil.OutletAirTemp, thisDXCoil.OutletAirHumRat, DataEnvironment::StdPressureSeaLevel, RoutineName);
 
-            state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
+            ReportCoilSelection::setRatedCoilConditions(
                 state,
                 thisDXCoil.Name,
-                thisDXCoil.DXCoilType,
+                thisDXCoil.coilType,
                 thisDXCoil.TotalCoolingEnergyRate, // this is the report variable
                 thisDXCoil.SensCoolingEnergyRate,  // this is the report variable
                 thisDXCoil.InletAirMassFlowRate,
@@ -6950,19 +7032,19 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             state.dataEnvrn->OutBaroPress = holdOutBaroPress;
         }
 
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+        if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
             for (DehumidModeNum = 0; DehumidModeNum <= thisDXCoil.NumDehumidModes; ++DehumidModeNum) {
                 for (CapacityStageNum = 1; CapacityStageNum <= thisDXCoil.NumCapacityStages; ++CapacityStageNum) {
                     Mode = DehumidModeNum * 2 + CapacityStageNum;
                     // Check for zero capacity or zero max flow rate
                     if (thisDXCoil.RatedTotCap(Mode) <= 0.0) {
-                        ShowSevereError(state, format("Sizing: {} {} has zero rated total capacity", thisDXCoil.DXCoilType, thisDXCoil.Name));
-                        ShowContinueError(state, format("for CoilPerformance:DX:Cooling mode: {}", thisDXCoil.CoilPerformanceName(Mode)));
+                      ShowSevereError(state, format("Sizing: {} {} has zero rated total capacity", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
+                        ShowContinueError(state, format("for CoilPerformance:DX:Cooling mode: {}", thisDXCoil.coilPerformanceNames(Mode)));
                         ErrorsFound = true;
                     }
                     if (thisDXCoil.RatedAirVolFlowRate(Mode) <= 0.0) {
-                        ShowSevereError(state, format("Sizing: {} {} has zero rated air flow rate", thisDXCoil.DXCoilType, thisDXCoil.Name));
-                        ShowContinueError(state, format("for CoilPerformance:DX:Cooling mode: {}", thisDXCoil.CoilPerformanceName(Mode)));
+                      ShowSevereError(state, format("Sizing: {} {} has zero rated air flow rate", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
+                        ShowContinueError(state, format("for CoilPerformance:DX:Cooling mode: {}", thisDXCoil.coilPerformanceNames(Mode)));
                         ErrorsFound = true;
                     }
                     if (ErrorsFound) {
@@ -6975,7 +7057,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
                         ShowWarningError(
                             state,
                             format("Sizing: {} \"{}\": Rated air volume flow rate per watt of rated total cooling capacity is out of range.",
-                                   thisDXCoil.DXCoilType,
+                                   HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                    thisDXCoil.Name));
                         ShowContinueError(state,
                                           format("Min Rated Vol Flow Per Watt=[{:.3T}], Rated Vol Flow Per Watt=[{:.3T}], Max Rated Vol Flow Per "
@@ -6983,15 +7065,15 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
                                                  HVAC::MinRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
                                                  RatedVolFlowPerRatedTotCap,
                                                  HVAC::MaxRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
-                        ShowContinueError(state, format("for CoilPerformance:DX:Cooling mode: {}", thisDXCoil.CoilPerformanceName(Mode)));
+                        ShowContinueError(state, format("for CoilPerformance:DX:Cooling mode: {}", thisDXCoil.coilPerformanceNames(Mode)));
                     }
                     thisDXCoil.RatedAirMassFlowRate(Mode) =
                         thisDXCoil.RatedAirVolFlowRate(Mode) *
                         PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
                     // get rated coil bypass factor
                     thisDXCoil.RatedCBF(Mode) = CalcCBF(state,
-                                                        thisDXCoil.CoilPerformanceType(Mode),
-                                                        thisDXCoil.CoilPerformanceName(Mode),
+                                                        thisDXCoil.coilPerformanceTypes(Mode),
+                                                        thisDXCoil.coilPerformanceNames(Mode),
                                                         RatedInletAirTemp,
                                                         RatedInletAirHumRat,
                                                         thisDXCoil.RatedTotCap(Mode),
@@ -7001,16 +7083,17 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             }     // End dehumidification modes loop
         }
 
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical || thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating ||
-            thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Heating) {
+        if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+            thisDXCoil.coilType == HVAC::CoilType::HeatingVRF ||
+            thisDXCoil.coilType == HVAC::CoilType::HeatingVRFFluidTCtrl) {
 
             Mode = 1;
             if (thisDXCoil.RatedTotCap(Mode) <= 0.0) {
-                ShowSevereError(state, format("Sizing: {} {} has zero rated total capacity", thisDXCoil.DXCoilType, thisDXCoil.Name));
+              ShowSevereError(state, format("Sizing: {} {} has zero rated total capacity", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                 ErrorsFound = true;
             }
             if (thisDXCoil.RatedAirVolFlowRate(Mode) <= 0.0) {
-                ShowSevereError(state, format("Sizing: {} {} has zero rated air flow rate", thisDXCoil.DXCoilType, thisDXCoil.Name));
+              ShowSevereError(state, format("Sizing: {} {} has zero rated air flow rate", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                 ErrorsFound = true;
             }
             if (ErrorsFound) {
@@ -7023,14 +7106,14 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
                 PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedHeatPumpIndoorAirTemp, RatedHeatPumpIndoorHumRat, RoutineName);
 
             // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
-            if (thisDXCoil.DXCoilType_Num !=
-                HVAC::CoilVRF_FluidTCtrl_Heating) { // the VolFlowPerRatedTotCap check is not applicable for VRF-FluidTCtrl coil
+            // the VolFlowPerRatedTotCap check is not applicable for VRF-FluidTCtrl coil
+            if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRFFluidTCtrl) { 
                 RatedVolFlowPerRatedTotCap = thisDXCoil.RatedAirVolFlowRate(Mode) / thisDXCoil.RatedTotCap(Mode);
                 if (((HVAC::MinRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT] - RatedVolFlowPerRatedTotCap) > SmallDifferenceTest) ||
                     ((RatedVolFlowPerRatedTotCap - HVAC::MaxRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) > SmallDifferenceTest)) {
                     ShowWarningError(state,
                                      format("Sizing: {} {}: Rated air volume flow rate per watt of rated total heating capacity is out of range.",
-                                            thisDXCoil.DXCoilType,
+                                            HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                             thisDXCoil.Name));
                     ShowContinueError(state,
                                       format("Min Rated Vol Flow Per Watt=[{:.3T}], Rated Vol Flow Per Watt=[{:.3T}], Max Rated Vol Flow Per "
@@ -7072,11 +7155,11 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             }
 
             // calculate coil model at rating point
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
+            if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed) {
                 CalcDXHeatingCoil(state, DXCoilNum, 1.0, HVAC::FanOp::Cycling, 1.0);
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingVRF) {
                 CalcDXHeatingCoil(state, DXCoilNum, 1.0, HVAC::FanOp::Cycling, _, _);
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Heating) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingVRFFluidTCtrl) {
                 CalcVRFHeatingCoil_FluidTCtrl(state, HVAC::CompressorOp::On, DXCoilNum, 1.0, HVAC::FanOp::Cycling, _, _);
             }
             // coil outlets
@@ -7084,10 +7167,10 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
                 state, thisDXCoil.OutletAirTemp, thisDXCoil.OutletAirHumRat, DataEnvironment::StdPressureSeaLevel, RoutineName);
 
-            state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
+            ReportCoilSelection::setRatedCoilConditions(
                 state,
                 thisDXCoil.Name,
-                thisDXCoil.DXCoilType,
+                thisDXCoil.coilType,
                 thisDXCoil.TotalHeatingEnergyRate, // this is the report variable
                 thisDXCoil.TotalHeatingEnergyRate, // this is the report variable
                 thisDXCoil.InletAirMassFlowRate,
@@ -7109,7 +7192,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
             state.dataEnvrn->OutBaroPress = holdOutBaroPress;
         }
 
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+        if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
             // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
             RatedVolFlowPerRatedTotCap = thisDXCoil.RatedAirVolFlowRate2 / thisDXCoil.RatedTotCap2;
             if (((HVAC::MinRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT] - RatedVolFlowPerRatedTotCap) > SmallDifferenceTest) ||
@@ -7131,7 +7214,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
                 PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
             // get low speed rated coil bypass factor
             thisDXCoil.RatedCBF2 = CalcCBF(state,
-                                           thisDXCoil.DXCoilType,
+                                           thisDXCoil.coilType,
                                            thisDXCoil.Name,
                                            RatedInletAirTemp,
                                            RatedInletAirHumRat,
@@ -7146,17 +7229,17 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         }
 
         // Multispeed Cooling
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+        if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed) {
             for (Mode = 1; Mode <= thisDXCoil.NumOfSpeeds; ++Mode) {
                 // Check for zero capacity or zero max flow rate
                 if (thisDXCoil.MSRatedTotCap(Mode) <= 0.0) {
                     ShowSevereError(state,
-                                    format("Sizing: {} {} has zero rated total capacity at speed {}", thisDXCoil.DXCoilType, thisDXCoil.Name, Mode));
+                                    format("Sizing: {} {} has zero rated total capacity at speed {}", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name, Mode));
                     ErrorsFound = true;
                 }
                 if (thisDXCoil.MSRatedAirVolFlowRate(Mode) <= 0.0) {
                     ShowSevereError(state,
-                                    format("Sizing: {} {} has zero rated air flow rate at speed {}", thisDXCoil.DXCoilType, thisDXCoil.Name, Mode));
+                                    format("Sizing: {} {} has zero rated air flow rate at speed {}", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name, Mode));
                     ErrorsFound = true;
                 }
                 if (ErrorsFound) {
@@ -7169,7 +7252,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
                     ShowWarningError(
                         state,
                         format("Sizing: {} \"{}\": Rated air volume flow rate per watt of rated total cooling capacity is out of range at speed {}",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                Mode));
                     ShowContinueError(state,
@@ -7184,7 +7267,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
                     PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
                 // get high speed rated coil bypass factor
                 thisDXCoil.MSRatedCBF(Mode) = CalcCBF(state,
-                                                      thisDXCoil.DXCoilType,
+                                                      thisDXCoil.coilType,
                                                       thisDXCoil.Name,
                                                       RatedInletAirTemp,
                                                       RatedInletAirHumRat,
@@ -7195,7 +7278,7 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         }
 
         // Multispeed Heating
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+        if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
             RatedHeatPumpIndoorAirTemp = 21.11;  // 21.11C or 70F
             RatedHeatPumpIndoorHumRat = 0.00881; // Humidity ratio corresponding to 70F dry bulb/60F wet bulb
             for (Mode = 1; Mode <= thisDXCoil.NumOfSpeeds; ++Mode) {
@@ -7223,8 +7306,8 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         }
 
         // store fan info for coil
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-            state, thisDXCoil.Name, thisDXCoil.DXCoilType, thisDXCoil.SupplyFanName, thisDXCoil.supplyFanType, thisDXCoil.SupplyFanIndex);
+        ReportCoilSelection::setCoilSupplyFanInfo(
+            state, thisDXCoil.Name, thisDXCoil.coilType, thisDXCoil.SupplyFanName, thisDXCoil.supplyFanType, thisDXCoil.SupplyFanIndex);
     }
 
     AirInletNode = thisDXCoil.AirInNode;
@@ -7240,7 +7323,8 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
     //  Eventually inlet air conditions will be used in DX Coil, these lines are commented out and marked with this comment line
     //  DXCoil(DXCoilNum)%InletAirPressure        = Node(AirInletNode)%Press
 
-    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+    if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+        thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
         if (thisDXCoil.IsSecondaryDXCoilInZone) {
             thisDXCoil.EvapInletWetBulb = PsyTwbFnTdbWPb(state,
                                                          state.dataZoneTempPredictorCorrector->zoneHeatBalance(thisDXCoil.SecZonePtr).ZT,
@@ -7250,7 +7334,8 @@ void InitDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the cur
         }
     }
 
-    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+    if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+        thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
         thisDXCoil.TotalHeatingEnergyRate = 0.0;
         thisDXCoil.ElecWaterHeatingPower = 0.0;
         //  Eventually inlet air conditions will be used in DX Coil, these lines are commented out and marked with this comment line
@@ -7382,13 +7467,13 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
     for (DehumidModeNum = 0; DehumidModeNum <= thisDXCoil.NumDehumidModes; ++DehumidModeNum) {
         for (CapacityStageNum = 1; CapacityStageNum <= thisDXCoil.NumCapacityStages; ++CapacityStageNum) {
             Mode = DehumidModeNum * 2 + CapacityStageNum;
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+            if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
                 if (thisDXCoil.RatedAirVolFlowRate(1) == Constant::AutoCalculate) {
                     // report autocalculated sizing
                     PrintFlag = true;
                     CompName = thisDXCoil.Name;
-                    CompType = thisDXCoil.DXCoilType;
+                    CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                     // DXCoil( DXCoilNum ).RatedAirVolFlowRate( 1 ) = DXCoil( DXCoilNum ).RatedTotCap2 * 0.00005035
                     state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedTotCap2;
                     state.dataSize->DataFractionUsedForSizing = 0.00005035;
@@ -7406,7 +7491,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                     // report autocalculated sizing
                     PrintFlag = true;
                     CompName = thisDXCoil.Name;
-                    CompType = thisDXCoil.DXCoilType;
+                    CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                     // DXCoil( DXCoilNum ).RatedAirVolFlowRate( 1 ) = DXCoil( DXCoilNum ).RatedTotCap2 * 0.00000004487
                     state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedTotCap2;
                     state.dataSize->DataFractionUsedForSizing = 0.00000004487;
@@ -7422,11 +7507,11 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             } else {
                 PrintFlag = true;
                 FieldNum = 0;
-                if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                    CompName = thisDXCoil.Name + ":" + thisDXCoil.CoilPerformanceName(Mode);
+                if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    CompName = thisDXCoil.Name + ":" + thisDXCoil.coilPerformanceNames(Mode);
                     FieldNum = 4;
                     state.dataSize->DataBypassFrac = thisDXCoil.BypassedFlowFrac(Mode);
-                } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
+                } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed) {
                     CompName = thisDXCoil.Name;
                     FieldNum = 3;
                     // doesn't look like this is needed for air flow sizing, only for heating capacity sizing
@@ -7437,21 +7522,21 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                          DataHeatBalance::RefrigCondenserType::Air)) { // secondary DX coil in secondary zone is specified
                         SizeSecDXCoil = true;
                     }
-                } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating) {
+                } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingVRF) {
                     CompName = thisDXCoil.Name;
                     FieldNum = 2;
-                } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Cooling) {
+                } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingVRF) {
                     CompName = thisDXCoil.Name;
                     FieldNum = 3;
-                } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Heating) {
+                } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingVRFFluidTCtrl) {
                     CompName = thisDXCoil.Name;
-                } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
+                } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
                     CompName = thisDXCoil.Name;
-                } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed) {
                     thisDXCoil.RatedAirVolFlowRate(Mode) = thisDXCoil.MSRatedAirVolFlowRate(thisDXCoil.NumOfSpeeds);
                     CompName = thisDXCoil.Name;
                     PrintFlag = false;
-                } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+                } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                     thisDXCoil.RatedAirVolFlowRate(Mode) = thisDXCoil.MSRatedAirVolFlowRate(thisDXCoil.NumOfSpeeds);
                     CompName = thisDXCoil.Name;
                     PrintFlag = false;
@@ -7466,12 +7551,12 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 } else {
                     SizingString = "Rated Air Flow Rate [m3/s]";
                 }
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 state.dataSize->DataIsDXCoil = true;
                 state.dataSize->DataEMSOverrideON = thisDXCoil.RatedAirVolFlowRateEMSOverrideON(Mode);
                 state.dataSize->DataEMSOverride = thisDXCoil.RatedAirVolFlowRateEMSOverrideValue(Mode);
-                if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating || thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Heating ||
-                    thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
+                if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed || thisDXCoil.coilType == HVAC::CoilType::HeatingVRFFluidTCtrl ||
+                    thisDXCoil.coilType == HVAC::CoilType::HeatingVRF || thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed) {
                     bool errorsFound = false;
                     HeatingAirFlowSizer sizingHeatingAirFlow;
                     sizingHeatingAirFlow.overrideSizingString(SizingString);
@@ -7498,16 +7583,16 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             // suite was not run with this code included. *** The question here is if the autosized air flow rate or the user specified air flow
             // rate should be used to calculate capacity removing this for now until more is known
             //                if ( DXCoil( DXCoilNum ).RatedTotCap( Mode ) != AutoSize && ( ( SysSizingRunDone && CurSysNum > 0 ) ||
-            //(  ZoneSizingRunDone && CurZoneEqNum > 0 ) ) ) {                     if ( DXCoil( DXCoilNum ).DXCoilType_Num ==
-            // HVAC::CoilDX_CoolingTwoStageWHumControl ) {                         SizingMethod = CoolingAirflowSizing;
+            //(  ZoneSizingRunDone && CurZoneEqNum > 0 ) ) ) {                     if ( DXCoil( DXCoilNum ).coilType ==
+            // HVAC::CoilType::DX_CoolingTwoStageWHumControl ) {                         SizingMethod = CoolingAirflowSizing;
             //                        DataBypassFrac = DXCoil ( DXCoilNum ).BypassedFlowFrac ( Mode );
-            //                    } else if ( DXCoil( DXCoilNum ).DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical ) {
+            //                    } else if ( DXCoil( DXCoilNum ).coilType == HVAC::CoilType::DX_HeatingEmpirical ) {
             //                        SizingMethod = HeatingAirflowSizing;
             ////                        DataCoolCoilCap = DXCoolCap; // pass global variable used only for heat pumps (i.e.,
             /// DX  cooling  and  heating coils)
-            //                    } else if ( DXCoil( DXCoilNum ).DXCoilType_Num == HVAC::CoilVRF_Heating ) {
+            //                    } else if ( DXCoil( DXCoilNum ).coilType == HVAC::CoilType::VRF_Heating ) {
             //                        SizingMethod = HeatingAirflowSizing;
-            //                    } else if ( DXCoil( DXCoilNum ).DXCoilType_Num == HVAC::CoilVRF_Cooling ) {
+            //                    } else if ( DXCoil( DXCoilNum ).coilType == HVAC::CoilType::VRF_Cooling ) {
             //                        SizingMethod = CoolingAirflowSizing;
             //                    } else {
             //                        SizingMethod = CoolingAirflowSizing;
@@ -7530,20 +7615,21 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             //                }
             PrintFlag = true;
             state.dataSize->DataTotCapCurveIndex = thisDXCoil.CCapFTemp(Mode);
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                CompName = thisDXCoil.Name + ":" + thisDXCoil.CoilPerformanceName(Mode);
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                CompName = thisDXCoil.Name + ":" + thisDXCoil.coilPerformanceNames(Mode);
                 FieldNum = 1;
                 TempSize = thisDXCoil.RatedTotCap(Mode);
                 SizingString = state.dataDXCoils->DXCoilNumericFields(DXCoilNum).PerfMode(Mode).FieldNames(FieldNum) + " [W]";
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical || thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating ||
-                       thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Heating) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+                       thisDXCoil.coilType == HVAC::CoilType::HeatingVRF ||
+                       thisDXCoil.coilType == HVAC::CoilType::HeatingVRFFluidTCtrl) {
                 CompName = thisDXCoil.Name;
                 FieldNum = 1;
                 TempSize = thisDXCoil.RatedTotCap(Mode);
                 SizingString = state.dataDXCoils->DXCoilNumericFields(DXCoilNum).PerfMode(Mode).FieldNames(FieldNum) + " [W]";
                 state.dataSize->DataCoolCoilCap = state.dataSize->DXCoolCap;
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                       thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                       thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
                 CompName = thisDXCoil.Name;
                 FieldNum = 1;
                 TempSize = thisDXCoil.RatedTotCap(Mode);
@@ -7551,7 +7637,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 PrintFlag = false;
                 state.dataLoopNodes->Node(thisDXCoil.WaterInNode).Temp =
                     thisDXCoil.RatedInletWaterTemp; // set the rated water inlet node for HPWHs for use in CalcHPWHDXCoil
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
                 CompName = thisDXCoil.Name;
                 FieldNum = 1;
                 TempSize = thisDXCoil.RatedTotCap(Mode);
@@ -7569,14 +7655,14 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                     }
                 }
                 CalcVRFCoilCapModFac(state, 0, _, CompName, CoilInTemp, _, _, _, state.dataSize->DataTotCapCurveValue);
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed) {
                 CompName = thisDXCoil.Name;
                 FieldNum = 7 + (thisDXCoil.NumOfSpeeds - 1) * 13;
                 state.dataSize->DataTotCapCurveIndex = thisDXCoil.MSCCapFTemp(thisDXCoil.NumOfSpeeds);
                 TempSize = thisDXCoil.MSRatedTotCap(thisDXCoil.NumOfSpeeds);
                 PrintFlag = false;
                 SizingString = state.dataDXCoils->DXCoilNumericFields(DXCoilNum).PerfMode(Mode).FieldNames(FieldNum) + " [W]";
-            } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+            } else if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                 CompName = thisDXCoil.Name;
                 FieldNum = 10 + (thisDXCoil.NumOfSpeeds - 1) * 6;
                 state.dataSize->DataTotCapCurveIndex = thisDXCoil.MSCCapFTemp(thisDXCoil.NumOfSpeeds);
@@ -7589,12 +7675,14 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 TempSize = thisDXCoil.RatedTotCap(Mode);
                 SizingString = state.dataDXCoils->DXCoilNumericFields(DXCoilNum).PerfMode(Mode).FieldNames(FieldNum) + " [W]";
             }
-            CompType = thisDXCoil.DXCoilType;
+            CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
             state.dataSize->DataIsDXCoil = true;
             state.dataSize->DataEMSOverrideON = thisDXCoil.RatedTotCapEMSOverrideOn(Mode);
             state.dataSize->DataEMSOverride = thisDXCoil.RatedTotCapEMSOverrideValue(Mode);
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Heating || thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Heating) {
+            if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed ||
+                thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+                thisDXCoil.coilType == HVAC::CoilType::HeatingVRF ||
+                thisDXCoil.coilType == HVAC::CoilType::HeatingVRFFluidTCtrl) {
                 HeatingCapacitySizer sizerHeatingCapacity;
                 sizerHeatingCapacity.overrideSizingString(SizingString);
                 sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
@@ -7616,23 +7704,28 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             state.dataSize->DataTotCapCurveValue = 0.0;
 
             // Cooling coil capacity
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl || thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Cooling ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingVRF ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
                 state.dataSize->DXCoolCap = thisDXCoil.RatedTotCap(Mode);
             }
 
             // Sizing DX cooling coil SHR
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl || thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_Cooling ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilVRF_FluidTCtrl_Cooling) {
-
-                if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                    CompName = thisDXCoil.Name + ":" + thisDXCoil.CoilPerformanceName(Mode);
+            // Why is this complex condition exactly the same as the previous one?
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingVRF ||
+                thisDXCoil.coilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
+
+                if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    CompName = thisDXCoil.Name + ":" + thisDXCoil.coilPerformanceNames(Mode);
                 } else {
                     CompName = thisDXCoil.Name;
                 }
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 TempSize = thisDXCoil.RatedSHR(Mode);
                 state.dataSize->DataDXSpeedNum = Mode;
                 state.dataSize->DataFlowUsedForSizing = thisDXCoil.RatedAirVolFlowRate(Mode);
@@ -7652,17 +7745,18 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
 
             // Sizing evaporator condenser air flow
             if (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap && thisDXCoil.EvapCondAirFlow(Mode) != 0.0 &&
-                (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-                 thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
+                (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                 thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+                 thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl)) {
 
                 AutoCalculateSizer sizerEvapCondAirFlow;
                 std::string stringOverride = "Evaporative Condenser Air Flow Rate [m3/s]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "evaporative_condenser_air_flow_rate [m3/s]";
-                if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                    CompName = thisDXCoil.Name + ":" + thisDXCoil.CoilPerformanceName(Mode);
+                if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    CompName = thisDXCoil.Name + ":" + thisDXCoil.coilPerformanceNames(Mode);
                 } else {
                     CompName = thisDXCoil.Name;
-                    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                    if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                         stringOverride = "High Speed Evaporative Condenser Air Flow Rate [m3/s]";
                         if (state.dataGlobal->isEpJSON) stringOverride = "high_speed_evaporative_condenser_air_flow_rate [m3/s]";
                     } else {
@@ -7670,7 +7764,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                         if (state.dataGlobal->isEpJSON) stringOverride = "evaporative_condenser_air_flow_rate [m3/s]";
                     }
                 }
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 // Auto-size condenser air flow to Total Capacity * 0.000114 m3/s/w (850 cfm/ton)
                 state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedTotCap(Mode);
                 state.dataSize->DataFractionUsedForSizing = 0.000114;
@@ -7690,12 +7784,12 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 if (IsAutoSize) {
                     thisDXCoil.SecCoilAirFlow = SecCoilAirFlowDes;
                     BaseSizer::reportSizerOutput(
-                        state, thisDXCoil.DXCoilType, thisDXCoil.Name, "Design Size Secondary Coil Air Flow Rate [m3/s]", SecCoilAirFlowDes);
+                        state, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name, "Design Size Secondary Coil Air Flow Rate [m3/s]", SecCoilAirFlowDes);
                 } else {
                     if (thisDXCoil.SecCoilAirFlow > 0.0 && SecCoilAirFlowDes > 0.0 && !HardSizeNoDesRun) {
                         SecCoilAirFlowUser = thisDXCoil.SecCoilAirFlow;
                         BaseSizer::reportSizerOutput(state,
-                                                     thisDXCoil.DXCoilType,
+                                                     HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                      thisDXCoil.Name,
                                                      "Design Size Secondary Coil Air Flow Rate [m3/s]",
                                                      SecCoilAirFlowDes,
@@ -7705,7 +7799,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                             if ((std::abs(SecCoilAirFlowDes - SecCoilAirFlowUser) / SecCoilAirFlowUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(
                                     state,
-                                    format("SizeDxCoil: Potential issue with equipment sizing for {} {}", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                                    format("SizeDxCoil: Potential issue with equipment sizing for {} {}", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                                 ShowContinueError(state, format("User-Specified Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowUser));
                                 ShowContinueError(
                                     state, format("differs from Design Size Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowDes));
@@ -7720,11 +7814,11 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             // Sizing evaporative condenser air flow 2
             PrintFlag = true;
             if (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap && thisDXCoil.EvapCondAirFlow2 != 0.0 &&
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 CompName = thisDXCoil.Name;
                 FieldNum = 15; // Low Speed Evaporative Condenser Air Flow Rate
                 SizingString = state.dataDXCoils->DXCoilNumericFields(DXCoilNum).PerfMode(Mode).FieldNames(FieldNum) + " [m3/s]";
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 // Autosize low speed condenser air flow to 1/3 Total Capacity * 0.000114 m3/s/w (850 cfm/ton)
                 state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedTotCap(Mode);
                 state.dataSize->DataFractionUsedForSizing = 0.000114 * 0.3333;
@@ -7739,17 +7833,18 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
 
             // Sizing evaporative condenser pump electric nominal power
             if (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap && thisDXCoil.EvapCondPumpElecNomPower(Mode) != 0.0 &&
-                (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-                 thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
+                (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                 thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+                 thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl)) {
 
                 AutoCalculateSizer sizerEvapCondPumpPower;
                 std::string stringOverride = "Evaporative Condenser Pump Rated Power Consumption [W]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "evaporative_condenser_pump_rated_power_consumption [W]";
-                if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                    CompName = thisDXCoil.Name + ":" + thisDXCoil.CoilPerformanceName(Mode);
+                if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    CompName = thisDXCoil.Name + ":" + thisDXCoil.coilPerformanceNames(Mode);
                 } else {
                     CompName = thisDXCoil.Name;
-                    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                    if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                         stringOverride = "High Speed Evaporative Condenser Pump Rated Power Consumption [W]";
                         if (state.dataGlobal->isEpJSON) stringOverride = "high_speed_evaporative_condenser_pump_rated_power_consumption [W]";
                     } else {
@@ -7757,7 +7852,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                         if (state.dataGlobal->isEpJSON) stringOverride = "evaporative_condenser_pump_rated_power_consumption [W]";
                     }
                 }
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 // Autosize high speed evap condenser pump power to Total Capacity * 0.004266 w/w (15 w/ton)
                 state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedTotCap(Mode);
                 state.dataSize->DataFractionUsedForSizing = 0.004266;
@@ -7769,9 +7864,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
 
             // Sizing low speed evaporative condenser pump electric nominal power
             if (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap && thisDXCoil.EvapCondPumpElecNomPower2 != 0.0 &&
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 CompName = thisDXCoil.Name;
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 // Autosize low speed evap condenser pump power to 1/3 Total Capacity * 0.004266 w/w (15 w/ton)
                 state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedTotCap(Mode);
                 state.dataSize->DataFractionUsedForSizing = 0.004266 * 0.3333;
@@ -7785,9 +7880,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             }
 
             //                // Sizing rated low speed air flow rate
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 CompName = thisDXCoil.Name;
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 // Autosize low speed air flow rate to 1/3 high speed air flow rate
                 state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedAirVolFlowRate(Mode);
                 state.dataSize->DataFractionUsedForSizing = 0.3333;
@@ -7801,9 +7896,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             }
 
             //                // Sizing rated low speed total cooling capacity
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 CompName = thisDXCoil.Name;
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 // Autosize low speed capacity to 1/3 high speed capacity
                 state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedTotCap(Mode);
                 state.dataSize->DataFractionUsedForSizing = 0.3333;
@@ -7816,12 +7911,12 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 thisDXCoil.RatedTotCap2 = sizerLowSpdCap.size(state, TempSize, ErrorsFound);
             }
 
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 if (thisDXCoil.EvapCondAirFlow2 > thisDXCoil.EvapCondAirFlow(Mode)) {
                     ShowSevereError(
                         state,
                         format("SizeDXCoil: {} {}, Evaporative Condenser low speed air flow must be less than or equal to high speed air flow.",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name));
                     ShowContinueError(state, format("Instead, {:.2R} > {:.2R}", thisDXCoil.EvapCondAirFlow2, thisDXCoil.EvapCondAirFlow(Mode)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
@@ -7831,7 +7926,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                     ShowSevereError(
                         state,
                         format("SizeDXCoil: {} {}, Evaporative Condenser low speed pump power must be less than or equal to high speed pump power.",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name));
                     ShowContinueError(
                         state, format("Instead, {:.2R} > {:.2R}", thisDXCoil.EvapCondPumpElecNomPower2, thisDXCoil.EvapCondPumpElecNomPower(Mode)));
@@ -7842,7 +7937,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                     ShowSevereError(state,
                                     format("SizeDXCoil: {} {}, Rated Total Cooling Capacity, Low Speed must be less than or equal to Rated Total "
                                            "Cooling Capacity, High Speed.",
-                                           thisDXCoil.DXCoilType,
+                                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                            thisDXCoil.Name));
                     ShowContinueError(state, format("Instead, {:.2R} > {:.2R}", thisDXCoil.RatedTotCap2, thisDXCoil.RatedTotCap(Mode)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
@@ -7852,7 +7947,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                     ShowFatalError(state,
                                    format("SizeDXCoil: {} {}, Rated Air Volume Flow Rate, low speed must be less than or equal to Rated Air Volume "
                                           "Flow Rate, high speed.",
-                                          thisDXCoil.DXCoilType,
+                                          HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                           thisDXCoil.Name));
                     ShowContinueError(state,
                                       format("Instead, {:.2R} > {:.2R}", thisDXCoil.RatedAirVolFlowRate2, thisDXCoil.RatedAirVolFlowRate(Mode)));
@@ -7861,11 +7956,11 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             }
 
             //                // Sizing rated low speed SHR2
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 CompName = thisDXCoil.Name;
                 FieldNum = 7;
                 SizingString = state.dataDXCoils->DXCoilNumericFields(DXCoilNum).PerfMode(Mode).FieldNames(FieldNum);
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 // Autosize low speed SHR to be the same as high speed SHR
                 state.dataSize->DataConstantUsedForSizing = thisDXCoil.RatedSHR(Mode);
                 state.dataSize->DataFractionUsedForSizing = 1.0;
@@ -7880,13 +7975,14 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             }
 
             //                // Sizing resistive defrost heater capacity
-            if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating && thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_FluidTCtrl_Heating &&
-                thisDXCoil.DXCoilType_Num != HVAC::CoilDX_MultiSpeedHeating) {
-                // IF (DXCoil(DXCoilNum)%DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating .OR. &
-                //    DXCoil(DXCoilNum)%DXCoilType_Num == Coil_HeatingAirToAirVariableSpeed) THEN
+            if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRF &&
+                thisDXCoil.coilType != HVAC::CoilType::HeatingVRFFluidTCtrl &&
+                thisDXCoil.coilType != HVAC::CoilType::HeatingDXMultiSpeed) {
+                // IF (DXCoil(DXCoilNum)%coilType == HVAC::CoilType::DX_MultiSpeedHeating .OR. &
+                //    DXCoil(DXCoilNum)%coilType == Coil_HeatingAirToAirVariableSpeed) THEN
                 if (thisDXCoil.DefrostStrategy == StandardRatings::DefrostStrat::Resistive) {
                     CompName = thisDXCoil.Name;
-                    CompType = thisDXCoil.DXCoilType;
+                    CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                     // Autosize low speed capacity to 1/3 high speed capacity
                     state.dataSize->DataConstantUsedForSizing = state.dataSize->DXCoolCap;
                     state.dataSize->DataFractionUsedForSizing = 1.0;
@@ -7906,7 +8002,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
     }     // End dehumidification modes loop
 
     // Autosizing for multispeed cooling coil
-    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+    if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed) {
         // flow rate autosize
         for (Mode = thisDXCoil.NumOfSpeeds; Mode >= 1; --Mode) {
             // Sizing multispeed air volume flow rate
@@ -7916,7 +8012,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             }
             state.dataSize->DataIsDXCoil = true;
             CompName = thisDXCoil.Name;
-            CompType = thisDXCoil.DXCoilType;
+            CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
             if (Mode == thisDXCoil.NumOfSpeeds) {
                 FieldNum = 10 + (Mode - 1) * 14;
                 SizingString = state.dataDXCoils->DXCoilNumericFields(DXCoilNum).PerfMode(1).FieldNames(FieldNum) + " [m3/s]";
@@ -7973,7 +8069,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             if (thisDXCoil.MSRatedAirVolFlowRate(Mode) > thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)) {
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
-                                        thisDXCoil.DXCoilType,
+                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                         thisDXCoil.Name,
                                         Mode,
                                         Mode + 1));
@@ -7990,7 +8086,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 IsAutoSize = true;
             }
             CompName = thisDXCoil.Name;
-            CompType = thisDXCoil.DXCoilType;
+            CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
             state.dataSize->DataIsDXCoil = true;
             state.dataSize->DataTotCapCurveIndex = thisDXCoil.MSCCapFTemp(Mode);
             if (Mode == thisDXCoil.NumOfSpeeds) {
@@ -8063,7 +8159,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Rated Total Cooling Capacity must be less than or equal to Speed {} Rated "
                                         "Total Cooling Capacity.",
-                                        thisDXCoil.DXCoilType,
+                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                         thisDXCoil.Name,
                                         Mode,
                                         Mode + 1));
@@ -8079,7 +8175,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 IsAutoSize = true;
             }
             if (Mode == thisDXCoil.NumOfSpeeds) {
-                CompType = thisDXCoil.DXCoilType;
+                CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
                 CompName = thisDXCoil.Name;
                 TempSize = thisDXCoil.MSRatedSHR(Mode);
                 state.dataSize->DataFlowUsedForSizing = MSRatedAirVolFlowRateDes;
@@ -8130,7 +8226,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             if (IsAutoSize) {
                 thisDXCoil.MSEvapCondAirFlow(Mode) = MSEvapCondAirFlowDes;
                 BaseSizer::reportSizerOutput(state,
-                                             thisDXCoil.DXCoilType,
+                                             HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                              thisDXCoil.Name,
                                              format("Design Size Speed {} Evaporative Condenser Air Flow Rate [m3/s]", Mode),
                                              MSEvapCondAirFlowDes);
@@ -8138,7 +8234,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 if (thisDXCoil.MSEvapCondAirFlow(Mode) > 0.0 && MSEvapCondAirFlowDes > 0.0 && !HardSizeNoDesRun) {
                     MSEvapCondAirFlowUser = thisDXCoil.MSEvapCondAirFlow(Mode);
                     BaseSizer::reportSizerOutput(state,
-                                                 thisDXCoil.DXCoilType,
+                                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                  thisDXCoil.Name,
                                                  format("Design Size Speed {} Evaporative Condenser Air Flow Rate [m3/s]", Mode),
                                                  MSEvapCondAirFlowDes,
@@ -8148,7 +8244,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                         if ((std::abs(MSEvapCondAirFlowDes - MSEvapCondAirFlowUser) / MSEvapCondAirFlowUser) >
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(
-                                state, format("SizeDxCoil: Potential issue with equipment sizing for {} {}", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                                state, format("SizeDxCoil: Potential issue with equipment sizing for {} {}", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                             ShowContinueError(state,
                                               format("User-Specified Evaporative Condenser Air Flow Rate of {:.5R} [m3/s]", MSEvapCondAirFlowUser));
                             ShowContinueError(
@@ -8167,7 +8263,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Evaporative Condenser Air Flow Rate must be less than or equal to Speed {} "
                                         "Evaporative Condenser Air Flow Rate.",
-                                        thisDXCoil.DXCoilType,
+                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                         thisDXCoil.Name,
                                         Mode,
                                         Mode + 1));
@@ -8195,7 +8291,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             if (IsAutoSize) {
                 thisDXCoil.MSEvapCondPumpElecNomPower(Mode) = MSEvapCondPumpElecNomPowerDes;
                 BaseSizer::reportSizerOutput(state,
-                                             thisDXCoil.DXCoilType,
+                                             HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                              thisDXCoil.Name,
                                              format("Design Size Speed {} Rated Evaporative Condenser Pump Power Consumption [W]", Mode),
                                              MSEvapCondPumpElecNomPowerDes);
@@ -8203,7 +8299,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 if (thisDXCoil.MSEvapCondPumpElecNomPower(Mode) > 0.0 && MSEvapCondPumpElecNomPowerDes > 0.0 && !HardSizeNoDesRun) {
                     MSEvapCondPumpElecNomPowerUser = thisDXCoil.MSEvapCondPumpElecNomPower(Mode);
                     BaseSizer::reportSizerOutput(state,
-                                                 thisDXCoil.DXCoilType,
+                                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                  thisDXCoil.Name,
                                                  format("Design Size Speed {} Rated Evaporative Condenser Pump Power Consumption [W]", Mode),
                                                  MSEvapCondPumpElecNomPowerDes,
@@ -8213,7 +8309,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                         if ((std::abs(MSEvapCondPumpElecNomPowerDes - MSEvapCondPumpElecNomPowerUser) / MSEvapCondPumpElecNomPowerUser) >
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(
-                                state, format("SizeDxCoil: Potential issue with equipment sizing for {} {}", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                                state, format("SizeDxCoil: Potential issue with equipment sizing for {} {}", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                             ShowContinueError(state,
                                               format("User-Specified Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
                                                      MSEvapCondPumpElecNomPowerUser));
@@ -8234,7 +8330,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Rated Evaporative Condenser Pump Power Consumption must be less than or "
                                         "equal to Speed {} Rated Evaporative Condenser Pump Power Consumption.",
-                                        thisDXCoil.DXCoilType,
+                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                         thisDXCoil.Name,
                                         Mode,
                                         Mode + 1));
@@ -8247,7 +8343,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
     }
 
     // Autosizing for multispeed heating coil
-    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+    if (thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
         // flow rate autosize
         for (Mode = thisDXCoil.NumOfSpeeds; Mode >= 1; --Mode) {
             IsAutoSize = false;
@@ -8256,7 +8352,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             }
             state.dataSize->DataIsDXCoil = true;
             CompName = thisDXCoil.Name;
-            CompType = thisDXCoil.DXCoilType;
+            CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
             // Sizing rated air flow rate
             if (Mode == thisDXCoil.NumOfSpeeds) {
                 FieldNum = 12 + (Mode - 1) * 6;
@@ -8311,7 +8407,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             if (thisDXCoil.MSRatedAirVolFlowRate(Mode) > thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)) {
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
-                                        thisDXCoil.DXCoilType,
+                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                         thisDXCoil.Name,
                                         Mode,
                                         Mode + 1));
@@ -8332,7 +8428,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 if (IsAutoSize) {
                     thisDXCoil.MSSecCoilAirFlow(Mode) = SecCoilAirFlowDes;
                     BaseSizer::reportSizerOutput(state,
-                                                 thisDXCoil.DXCoilType,
+                                                 HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                  thisDXCoil.Name,
                                                  format("Design Size Speed {} Secondary Coil Air Flow Rate [m3/s]", Mode),
                                                  SecCoilAirFlowDes);
@@ -8340,7 +8436,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                     if (thisDXCoil.MSSecCoilAirFlow(Mode) > 0.0 && SecCoilAirFlowDes > 0.0 && !HardSizeNoDesRun) {
                         SecCoilAirFlowUser = thisDXCoil.MSSecCoilAirFlow(Mode);
                         BaseSizer::reportSizerOutput(state,
-                                                     thisDXCoil.DXCoilType,
+                                                     HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                      thisDXCoil.Name,
                                                      format("Design Size Speed {} Secondary Coil Air Flow Rate [m3/s]", Mode),
                                                      SecCoilAirFlowDes,
@@ -8350,7 +8446,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                             if ((std::abs(SecCoilAirFlowDes - SecCoilAirFlowUser) / SecCoilAirFlowUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(
                                     state,
-                                    format("SizeDxCoil: Potential issue with equipment sizing for {} {}", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                                    format("SizeDxCoil: Potential issue with equipment sizing for {} {}", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                                 ShowContinueError(state, format("User-Specified Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowUser));
                                 ShowContinueError(
                                     state, format("differs from Design Size Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowDes));
@@ -8371,7 +8467,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
             }
             state.dataSize->DataIsDXCoil = true;
             CompName = thisDXCoil.Name;
-            CompType = thisDXCoil.DXCoilType;
+            CompType = HVAC::coilTypeNames[(int)thisDXCoil.coilType];
             if (Mode == thisDXCoil.NumOfSpeeds) {
                 state.dataSize->DataFlowUsedForSizing = thisDXCoil.MSRatedAirVolFlowRate(Mode);
                 FieldNum = 10 + (Mode - 1) * 6;
@@ -8448,7 +8544,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Rated Total Heating Capacity must be less than or equal to Speed {} Rated "
                                         "Total Heating Capacity.",
-                                        thisDXCoil.DXCoilType,
+                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                         thisDXCoil.Name,
                                         Mode,
                                         Mode + 1));
@@ -8471,12 +8567,12 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
         if (IsAutoSize) {
             thisDXCoil.DefrostCapacity = DefrostCapacityDes;
             BaseSizer::reportSizerOutput(
-                state, thisDXCoil.DXCoilType, thisDXCoil.Name, "Design Size Resistive Defrost Heater Capacity", DefrostCapacityDes);
+                state, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name, "Design Size Resistive Defrost Heater Capacity", DefrostCapacityDes);
         } else {
             if (thisDXCoil.DefrostCapacity > 0.0 && DefrostCapacityDes > 0.0 && !HardSizeNoDesRun) {
                 DefrostCapacityUser = thisDXCoil.DefrostCapacity;
                 BaseSizer::reportSizerOutput(state,
-                                             thisDXCoil.DXCoilType,
+                                             HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                              thisDXCoil.Name,
                                              "Design Size Resistive Defrost Heater Capacity",
                                              DefrostCapacityDes,
@@ -8485,7 +8581,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                 if (state.dataGlobal->DisplayExtraWarnings) {
                     if ((std::abs(DefrostCapacityDes - DefrostCapacityUser) / DefrostCapacityUser) > state.dataSize->AutoVsHardSizingThreshold) {
                         ShowWarningMessage(
-                            state, format("SizeDxCoil: Potential issue with equipment sizing for {} {}", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                            state, format("SizeDxCoil: Potential issue with equipment sizing for {} {}", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                         ShowContinueError(state, format("User-Specified Resistive Defrost Heater Capacity of {:.2R}[W]", DefrostCapacityUser));
                         ShowContinueError(state,
                                           format("differs from Design Size Resistive Defrost Heater Capacity of {:.2R}[W]", DefrostCapacityDes));
@@ -8498,14 +8594,13 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
     }
 
     // Call routine that computes AHRI certified rating for single-speed DX Coils
-    if ((thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed &&
+    if ((thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed &&
          (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Air ||
           thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap)) ||
-        thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
+        thisDXCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed) {
         CalcDXCoilStandardRating(state,
                                  thisDXCoil.Name,
-                                 thisDXCoil.DXCoilType,
-                                 thisDXCoil.DXCoilType_Num,
+                                 thisDXCoil.coilType,
                                  1,
                                  thisDXCoil.RatedTotCap(1),
                                  thisDXCoil.RatedCOP(1),
@@ -8526,11 +8621,11 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                  thisDXCoil.ASHRAE127StdRprt);
     }
     // Call routine that computes AHRI certified rating for multi-speed DX cooling Coils
-    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+    if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+        thisDXCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
         CalcDXCoilStandardRating(state,
                                  thisDXCoil.Name,
-                                 thisDXCoil.DXCoilType,
-                                 thisDXCoil.DXCoilType_Num,
+                                 thisDXCoil.coilType,
                                  thisDXCoil.NumOfSpeeds,
                                  thisDXCoil.MSRatedTotCap,
                                  thisDXCoil.MSRatedCOP,
@@ -8551,12 +8646,12 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                  ObjexxFCL::Optional_bool_const());
     }
 
-    if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed && (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Air ||
-                                                                      thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap)) {
+    if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed &&
+        (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Air ||
+         thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap)) {
         StandardRatings::CalcTwoSpeedDXCoilRating(state,
                                                   thisDXCoil.Name,
-                                                  thisDXCoil.DXCoilType,
-                                                  thisDXCoil.DXCoilType_Num,
+                                                  thisDXCoil.coilType,
                                                   thisDXCoil.RatedTotCap,
                                                   thisDXCoil.RatedTotCap2,
                                                   thisDXCoil.RatedCOP,
@@ -8578,12 +8673,12 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
     // create predefined report entries
     equipName = thisDXCoil.Name;
     // put tables for cooling and heating separate
-    switch (thisDXCoil.DXCoilType_Num) {
-    case HVAC::CoilDX_CoolingSingleSpeed:
-    case HVAC::CoilDX_CoolingTwoSpeed:
-    case HVAC::CoilDX_CoolingTwoStageWHumControl:
-    case HVAC::CoilDX_MultiSpeedCooling: {
-        PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilType, equipName, thisDXCoil.DXCoilType);
+    switch (thisDXCoil.coilType) {
+    case HVAC::CoilType::CoolingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoSpeed:
+    case HVAC::CoilType::CoolingDXTwoStageWHumControl:
+    case HVAC::CoilType::CoolingDXMultiSpeed: {
+        PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilType, equipName, HVAC::coilTypeNames[(int)thisDXCoil.coilType]);
         if (thisDXCoil.NumOfSpeeds == 0) {
             if (thisDXCoil.NumCapacityStages == 1) {
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilTotCap, equipName, thisDXCoil.RatedTotCap(1));
@@ -8623,11 +8718,12 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                             state.dataOutRptPredefined->pdstCoolCoil,
                             "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
     } break;
-    case HVAC::CoilDX_HeatingEmpirical:
-    case HVAC::CoilDX_MultiSpeedHeating:
-    case HVAC::CoilDX_HeatPumpWaterHeaterPumped:
-    case HVAC::CoilDX_HeatPumpWaterHeaterWrapped: {
-        PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilType, equipName, thisDXCoil.DXCoilType);
+      
+    case HVAC::CoilType::HeatingDXSingleSpeed:
+    case HVAC::CoilType::HeatingDXMultiSpeed:
+    case HVAC::CoilType::WaterHeatingDXPumped:
+    case HVAC::CoilType::WaterHeatingDXWrapped: {
+        PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilType, equipName, HVAC::coilTypeNames[(int)thisDXCoil.coilType]);
         if (thisDXCoil.NumOfSpeeds == 0) {
             if (thisDXCoil.NumCapacityStages == 1) {
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomCap, equipName, thisDXCoil.RatedTotCap(1));
@@ -8764,7 +8860,7 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
         //   Warn user if curve output goes negative
         if (HeatCapFTemp < 0.0) {
             if (Coil.HCapFTempErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", Coil.DXCoilType, Coil.Name));
+              ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name));
                 ShowContinueError(
                     state, format(" HPWH Heating Capacity Modifier curve (function of temperature) output is negative ({:.3T}).", HeatCapFTemp));
                 if (state.dataCurveManager->curves(Coil.HCapFTemp)->numDims == 2) {
@@ -8780,8 +8876,8 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                Coil.DXCoilType + " \"" + Coil.Name +
-                    "\": HPWH Heating Capacity Modifier curve (function of temperature) output is negative warning continues...",
+                format("{} \"{}\": HPWH Heating Capacity Modifier curve (function of temperature) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name),
                 Coil.HCapFTempErrorIndex,
                 HeatCapFTemp,
                 HeatCapFTemp,
@@ -8803,7 +8899,7 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
         //   Warn user if curve output goes negative
         if (HeatCOPFTemp < 0.0) {
             if (Coil.HCOPFTempErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", Coil.DXCoilType, Coil.Name));
+                ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name));
                 ShowContinueError(state,
                                   format(" HPWH Heating COP Modifier curve (function of temperature) output is negative ({:.3T}).", HeatCOPFTemp));
                 if (state.dataCurveManager->curves(Coil.HCOPFTemp)->numDims == 2) {
@@ -8819,8 +8915,8 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                Coil.DXCoilType + " \"" + Coil.Name +
-                    "\": HPWH Heating COP Modifier curve (function of temperature) output is negative warning continues...",
+                format("{} \"{}\": HPWH Heating COP Modifier curve (function of temperature) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name),
                 Coil.HCOPFTempErrorIndex,
                 HeatCOPFTemp,
                 HeatCOPFTemp,
@@ -8839,7 +8935,7 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
         //   Warn user if curve output goes negative
         if (HeatCapFAirFlow < 0.0) {
             if (Coil.HCapFAirFlowErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", Coil.DXCoilType, Coil.Name));
+                ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name));
                 ShowContinueError(
                     state,
                     format(" HPWH Heating Capacity Modifier curve (function of air flow fraction) output is negative ({:.3T}).", HeatCapFAirFlow));
@@ -8848,8 +8944,8 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                Coil.DXCoilType + " \"" + Coil.Name +
-                    "\": HPWH Heating Capacity Modifier curve (function of air flow fraction) output is negative warning continues...",
+                format("{} \"{}\": HPWH Heating Capacity Modifier curve (function of air flow fraction) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name),
                 Coil.HCapFAirFlowErrorIndex,
                 HeatCapFAirFlow,
                 HeatCapFAirFlow);
@@ -8865,7 +8961,7 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
         //   Warn user if curve output goes negative
         if (HeatCOPFAirFlow < 0.0) {
             if (Coil.HCOPFAirFlowErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", Coil.DXCoilType, Coil.Name));
+              ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name));
                 ShowContinueError(
                     state, format(" HPWH Heating COP Modifier curve (function of air flow fraction) output is negative ({:.3T}).", HeatCOPFAirFlow));
                 ShowContinueError(state, format(" Negative value occurs using an air flow fraction of {:.3T}.", AirFlowRateRatio));
@@ -8873,8 +8969,8 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                Coil.DXCoilType + " \"" + Coil.Name +
-                    "\": HPWH Heating COP Modifier curve (function of air flow fraction) output is negative warning continues...",
+                format("{} \"{}\": HPWH Heating COP Modifier curve (function of air flow fraction) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name),
                 Coil.HCOPFAirFlowErrorIndex,
                 HeatCOPFAirFlow,
                 HeatCOPFAirFlow);
@@ -8890,7 +8986,7 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
         //   Warn user if curve output goes negative
         if (HeatCapFWaterFlow < 0.0) {
             if (Coil.HCapFWaterFlowErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", Coil.DXCoilType, Coil.Name));
+                ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name));
                 ShowContinueError(state,
                                   format(" HPWH Heating Capacity Modifier curve (function of water flow fraction) output is negative ({:.3T}).",
                                          HeatCapFWaterFlow));
@@ -8899,8 +8995,8 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                Coil.DXCoilType + " \"" + Coil.Name +
-                    "\": HPWH Heating Capacity Modifier curve (function of water flow fraction) output is negative warning continues...",
+                format("{} \"{}\": HPWH Heating Capacity Modifier curve (function of water flow fraction) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name),
                 Coil.HCapFWaterFlowErrorIndex,
                 HeatCapFWaterFlow,
                 HeatCapFWaterFlow);
@@ -8916,7 +9012,7 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
         //   Warn user if curve output goes negative
         if (HeatCOPFWaterFlow < 0.0) {
             if (Coil.HCOPFWaterFlowErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", Coil.DXCoilType, Coil.Name));
+                ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name));
                 ShowContinueError(
                     state,
                     format(" HPWH Heating COP Modifier curve (function of water flow fraction) output is negative ({:.3T}).", HeatCOPFWaterFlow));
@@ -8925,8 +9021,8 @@ void CalcHPWHDXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                Coil.DXCoilType + " \"" + Coil.Name +
-                    "\": HPWH Heating COP Modifier curve (function of water flow fraction) output is negative warning continues...",
+                format("{} \"{}\": HPWH Heating COP Modifier curve (function of water flow fraction) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)Coil.coilType], Coil.Name),
                 Coil.HCOPFWaterFlowErrorIndex,
                 HeatCOPFWaterFlow,
                 HeatCOPFWaterFlow);
@@ -9086,6 +9182,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
 
     // SUBROUTINE PARAMETER DEFINITIONS:
     static constexpr std::string_view RoutineName("CalcDoe2DXCoil: ");
+    static constexpr std::string_view routineName = "CalcDoe2DXCoil";
     static constexpr std::string_view calcDoe2DXCoil("CalcDoe2DXCoil");
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
@@ -9291,8 +9388,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
             }
             if (thisDXCoil.CondenserType(Mode) == DataHeatBalance::RefrigCondenserType::Air) {
                 ShowRecurringWarningErrorAtEnd(state,
-                                               std::string{RoutineName} + thisDXCoil.DXCoilType + "=\"" + thisDXCoil.Name +
-                                                   "\" - Low condenser dry-bulb temperature error continues...",
+                                               format("{}: {}=\"{}\" - Low condenser dry-bulb temperature error continues...",
+                                                      routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                                thisDXCoil.LowAmbErrIndex,
                                                thisDXCoil.LowTempLast,
                                                thisDXCoil.LowTempLast,
@@ -9301,8 +9398,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                                                "[C]");
             } else {
                 ShowRecurringWarningErrorAtEnd(state,
-                                               std::string{RoutineName} + thisDXCoil.DXCoilType + "=\"" + thisDXCoil.Name +
-                                                   "\" - Low condenser wet-bulb temperature error continues...",
+                                               format("{}: {}=\"{}\" - Low condenser wet-bulb temperature error continues...",
+                                                      routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                                thisDXCoil.LowAmbErrIndex,
                                                thisDXCoil.LowTempLast,
                                                thisDXCoil.LowTempLast,
@@ -9327,9 +9424,10 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                                   "   3) is used as part of a HX assisted cooling coil which uses a high sensible effectiveness. Check inputs.");
             }
             ShowRecurringWarningErrorAtEnd(state,
-                                           std::string{RoutineName} + thisDXCoil.DXCoilType + "=\"" + thisDXCoil.Name +
-                                               "\" - Full load outlet temperature indicates a possibility of frost/freeze error continues. "
-                                               "Outlet air temperature statistics follow:",
+                                           format("{}: {}=\"{}\" - Full load outlet temperature indicates a possibility of frost/freeze error continues. "
+                                                  "Outlet air temperature statistics follow:",
+
+                                                  routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                            thisDXCoil.LowOutletTempIndex,
                                            thisDXCoil.FullLoadOutAirTempLast,
                                            thisDXCoil.FullLoadOutAirTempLast);
@@ -9343,13 +9441,13 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
     thisDXCoil.PrintLowOutTempMessage = false;
 
     if ((AirMassFlow > 0.0) &&
-        (thisDXCoil.availSched->getCurrentVal() > 0.0 || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-         thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) &&
+        (thisDXCoil.availSched->getCurrentVal() > 0.0 || thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+         thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) &&
         (PartLoadRatio > 0.0) && (compressorOp == HVAC::CompressorOp::On) &&
         CompAmbTemp > thisDXCoil.MinOATCompressor) { // criteria for coil operation
         if (fanOp == HVAC::FanOp::Cycling) {
             AirMassFlow /= (PartLoadRatio / DXcoolToHeatPLRRatio);
-        } else if (fanOp == HVAC::FanOp::Continuous && thisDXCoil.DXCoilType_Num != HVAC::CoilDX_CoolingTwoSpeed) {
+        } else if (fanOp == HVAC::FanOp::Continuous && thisDXCoil.coilType != HVAC::CoilType::CoolingDXTwoSpeed) {
             AirMassFlow *= AirFlowRatio;
         } else {
             AirMassFlow = thisDXCoil.RatedAirMassFlowRate(Mode);
@@ -9367,16 +9465,17 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
         //  AirVolumeFlowRate = AirMassFlow/ PsyRhoAirFnPbTdbW(InletAirPressure,InletAirDryBulbTemp, InletAirHumRat)
         if (thisDXCoil.RatedTotCap(Mode) <= 0.0) {
             ShowFatalError(
-                state, format("{}{}=\"{}\" - Rated total cooling capacity is zero or less.", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                state, format("{}{}=\"{}\" - Rated total cooling capacity is zero or less.", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
         }
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-            thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+        if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+            thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
             VolFlowperRatedTotCap = AirVolumeFlowRate / thisDXCoil.RatedTotCap2;
         } else {
             VolFlowperRatedTotCap = AirVolumeFlowRate / thisDXCoil.RatedTotCap(Mode);
         }
-        if (!FirstHVACIteration && !state.dataGlobal->WarmupFlag && thisDXCoil.DXCoilType_Num != HVAC::CoilDX_HeatPumpWaterHeaterPumped &&
-            thisDXCoil.DXCoilType_Num != HVAC::CoilDX_HeatPumpWaterHeaterWrapped &&
+        if (!FirstHVACIteration && !state.dataGlobal->WarmupFlag &&
+            thisDXCoil.coilType != HVAC::CoilType::WaterHeatingDXPumped &&
+            thisDXCoil.coilType != HVAC::CoilType::WaterHeatingDXWrapped &&
             ((VolFlowperRatedTotCap < HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) ||
              (VolFlowperRatedTotCap > HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]))) {
             if (thisDXCoil.ErrIndex1 == 0) {
@@ -9384,7 +9483,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                     state,
                     format("{}{}=\"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at {:.3R} m3/s/W.",
                            RoutineName,
-                           thisDXCoil.DXCoilType,
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                            thisDXCoil.Name,
                            VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
@@ -9397,14 +9496,14 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                std::string{RoutineName} + thisDXCoil.DXCoilType + "=\"" + thisDXCoil.Name +
-                    "\" - Air volume flow rate per watt of rated total cooling capacity is out of range error continues...",
-                thisDXCoil.ErrIndex1,
+                format("{}: {}=\"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range error continues...",
+                       routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
+                       thisDXCoil.ErrIndex1,
                 VolFlowperRatedTotCap,
                 VolFlowperRatedTotCap);
         } else if (!state.dataGlobal->WarmupFlag &&
-                   (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                    thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) &&
+                   (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                    thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) &&
                    ((VolFlowperRatedTotCap < HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) ||
                     (VolFlowperRatedTotCap > HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]))) {
             if (thisDXCoil.ErrIndex1 == 0) {
@@ -9412,7 +9511,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                     state,
                     format("{}{}=\"{}\" - Air volume flow rate per watt of rated total water heating capacity is out of range at {:.2R} m3/s/W.",
                            RoutineName,
-                           thisDXCoil.DXCoilType,
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                            thisDXCoil.Name,
                            VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
@@ -9426,8 +9525,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                std::string{RoutineName} + thisDXCoil.DXCoilType + "=\"" + thisDXCoil.Name +
-                    "\" - Air volume flow rate per watt of rated total water heating capacity is out of range error continues...",
+                format("{}: {}=\"{}\" - Air volume flow rate per watt of rated total water heating capacity is out of range error continues...",
+                       routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                 thisDXCoil.ErrIndex1,
                 VolFlowperRatedTotCap,
                 VolFlowperRatedTotCap);
@@ -9456,7 +9555,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 if (thisDXCoil.LowAmbErrIndex == 0) {
                     thisDXCoil.LowAmbBuffer1 =
                         format("{} \"{}\" - Air-cooled condenser inlet dry-bulb temperature below 0 C. Outdoor dry-bulb temperature = {:.2R}",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                OutdoorDryBulb);
                     thisDXCoil.LowAmbBuffer2 = " ... Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
@@ -9470,7 +9569,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 if (thisDXCoil.LowAmbErrIndex == 0) {
                     thisDXCoil.LowAmbBuffer1 =
                         format("{} \"{}\" - Evap-cooled condenser inlet wet-bulb temperature below 10 C. Outdoor wet-bulb temperature = {:.2R}",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                OutdoorWetBulb);
                     thisDXCoil.LowAmbBuffer2 = " ... Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
@@ -9484,8 +9583,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
         InletAirHumRatTemp = InletAirHumRat;
         AirMassFlowRatio = AirMassFlow / thisDXCoil.RatedAirMassFlowRate(Mode);
         while (true) {
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+            if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
                 // Coil:DX:HeatPumpWaterHeater does not have total cooling capacity as a function of temp or flow curve
                 TotCapTempModFac = 1.0;
                 TotCapFlowModFac = 1.0;
@@ -9499,7 +9598,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 //    Warn user if curve output goes negative
                 if (TotCapTempModFac < 0.0) {
                     if (thisDXCoil.CCapFTempErrorIndex == 0) {
-                        ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                        ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                         ShowContinueError(state,
                                           format(" Total Cooling Capacity Modifier curve (function of temperature) output is negative ({:.3T}).",
                                                  TotCapTempModFac));
@@ -9520,8 +9619,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                     }
                     ShowRecurringWarningErrorAtEnd(
                         state,
-                        std::string{RoutineName} + thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                            "\": Total Cooling Capacity Modifier curve (function of temperature) output is negative warning continues...",
+                        format("{}; {}=\"{}\" - Total Cooling Capacity Modifier curve (function of temperature) output is negative warning continues...",
+                               routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                         thisDXCoil.CCapFTempErrorIndex,
                         TotCapTempModFac,
                         TotCapTempModFac);
@@ -9533,7 +9632,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 //    Warn user if curve output goes negative
                 if (TotCapFlowModFac < 0.0) {
                     if (thisDXCoil.CCapFFlowErrorIndex == 0) {
-                        ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                        ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                         ShowContinueError(state,
                                           format(" Total Cooling Capacity Modifier curve (function of flow fraction) output is negative ({:.3T}).",
                                                  TotCapFlowModFac));
@@ -9545,8 +9644,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                     }
                     ShowRecurringWarningErrorAtEnd(
                         state,
-                        std::string{RoutineName} + thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                            "\": Total Cooling Capacity Modifier curve (function of flow fraction) output is negative warning continues...",
+                        format("{}: {}=\"{}\" - Total Cooling Capacity Modifier curve (function of flow fraction) output is negative warning continues..",
+                               routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                         thisDXCoil.CCapFFlowErrorIndex,
                         TotCapFlowModFac,
                         TotCapFlowModFac);
@@ -9607,26 +9706,31 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
 
         if (PLF < 0.7) {
             if (thisDXCoil.ErrIndex2 == 0) {
-                if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                    thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
-                    ShowWarningMessage(state, format("{}{}=\"{}\", PLF curve value", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                    thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
+                    ShowWarningMessage(state, format("{}{}=\"{}\", PLF curve value", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowContinueError(state, format("The PLF curve value = {:.3T} for part-load ratio = {:.3T}", PLF, PartLoadRatio));
                     ShowContinueErrorTimeStamp(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
-                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", thisDXCoil.DXCoilType));
+                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", HVAC::coilTypeNames[(int)thisDXCoil.coilType]));
                 } else {
-                    ShowWarningMessage(state, format("{}{}=\"{}\", PLF curve value", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                    ShowWarningMessage(state, format("{}{}=\"{}\", PLF curve value", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowContinueError(state, format("The PLF curve value = {:.3T} for part-load ratio = {:.3T}", PLF, PartLoadRatio));
                     ShowContinueErrorTimeStamp(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
-                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", thisDXCoil.DXCoilType));
+                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", HVAC::coilTypeNames[(int)thisDXCoil.coilType]));
                 }
             }
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+            if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
                 ShowRecurringWarningErrorAtEnd(
-                    state, thisDXCoil.Name + ", " + thisDXCoil.DXCoilType + " PLF curve < 0.7 warning continues...", thisDXCoil.ErrIndex2, PLF, PLF);
+                    state,
+                    format("{}=\"{}\" - PLF curve < 0.7 warning continues...", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
+                    thisDXCoil.ErrIndex2, PLF, PLF);
             } else {
                 ShowRecurringWarningErrorAtEnd(
-                    state, thisDXCoil.Name + ", " + thisDXCoil.DXCoilType + " PLF curve < 0.7 warning continues...", thisDXCoil.ErrIndex2, PLF, PLF);
+                    state,
+                    format("{}=\"{}\" - PLF curve < 0.7 warning continues...",
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
+                           thisDXCoil.ErrIndex2, PLF, PLF);
             }
             PLF = 0.7;
         }
@@ -9635,31 +9739,33 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
         thisDXCoil.CoolingCoilRuntimeFraction = PartLoadRatio / PLF;
         if (thisDXCoil.CoolingCoilRuntimeFraction > 1.0 && std::abs(thisDXCoil.CoolingCoilRuntimeFraction - 1.0) > 0.001) {
             if (thisDXCoil.ErrIndex3 == 0) {
-                if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                    thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
-                    ShowWarningMessage(state, format("{}{}=\"{}\", runtime fraction", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                    thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
+                    ShowWarningMessage(state, format("{}{}=\"{}\", runtime fraction", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowWarningMessage(state, format("The runtime fraction exceeded 1.0. [{:.4R}].", thisDXCoil.CoolingCoilRuntimeFraction));
                     ShowContinueError(state, "Runtime fraction reset to 1 and the simulation will continue.");
-                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", thisDXCoil.DXCoilType));
+                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", HVAC::coilTypeNames[(int)thisDXCoil.coilType]));
                     ShowContinueErrorTimeStamp(state, "");
                 } else {
-                    ShowWarningMessage(state, format("{}{}=\"{}\", runtime fraction", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                    ShowWarningMessage(state, format("{}{}=\"{}\", runtime fraction", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowWarningMessage(state, format("The runtime fraction exceeded 1.0. [{:.4R}].", thisDXCoil.CoolingCoilRuntimeFraction));
                     ShowContinueError(state, "Runtime fraction reset to 1 and the simulation will continue.");
-                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", thisDXCoil.DXCoilType));
+                    ShowContinueError(state, format("Check the IO reference manual for PLF curve guidance [{}].", HVAC::coilTypeNames[(int)thisDXCoil.coilType]));
                     ShowContinueErrorTimeStamp(state, "");
                 }
             }
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-                thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+            if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+                thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
                 ShowRecurringWarningErrorAtEnd(state,
-                                               thisDXCoil.Name + ", " + thisDXCoil.DXCoilType + " runtime fraction > 1.0 warning continues...",
+                                               format("{}=\"{}\" - runtime fraction > 1.0 warning continues...",
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                                thisDXCoil.ErrIndex3,
                                                thisDXCoil.CoolingCoilRuntimeFraction,
                                                thisDXCoil.CoolingCoilRuntimeFraction);
             } else {
                 ShowRecurringWarningErrorAtEnd(state,
-                                               thisDXCoil.Name + ", " + thisDXCoil.DXCoilType + " runtime fraction > 1.0 warning continues...",
+                                               format("{}=\"{}\" - runtime fraction > 1.0 warning continues...",
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                                thisDXCoil.ErrIndex3,
                                                thisDXCoil.CoolingCoilRuntimeFraction,
                                                thisDXCoil.CoolingCoilRuntimeFraction);
@@ -9718,7 +9824,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 thisDXCoil.FullLoadInletAirTempLast = InletAirDryBulbTemp;
                 thisDXCoil.LowOutTempBuffer1 = format("{} \"{}\" - Full load outlet air dry-bulb temperature < 2C. This indicates the "
                                                       "possibility of coil frost/freeze. Outlet temperature = {:.2R} C.",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       FullLoadOutAirTemp);
                 thisDXCoil.LowOutTempBuffer2 = " ...Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
@@ -9859,8 +9965,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
         }
 
         // Calculate electricity consumed. First, get EIR modifying factors for off-rated conditions
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterPumped ||
-            thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+        if (thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXPumped ||
+            thisDXCoil.coilType == HVAC::CoilType::WaterHeatingDXWrapped) {
             //   Coil:DX:HeatPumpWaterHeater does not have EIR temp or flow curves
             EIRTempModFac = 1.0;
             EIRFlowModFac = 1.0;
@@ -9870,7 +9976,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
             //   Warn user if curve output goes negative
             if (EIRTempModFac < 0.0) {
                 if (thisDXCoil.EIRFTempErrorIndex == 0) {
-                    ShowWarningMessage(state, format("{}{}=\"{}\":", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                    ShowWarningMessage(state, format("{}{}=\"{}\":", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowContinueError(
                         state, format(" Energy Input Ratio Modifier curve (function of temperature) output is negative ({:.3T}).", EIRTempModFac));
                     if (state.dataCurveManager->curves(thisDXCoil.EIRFTemp(Mode))->numDims == 2) {
@@ -9889,8 +9995,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 }
                 ShowRecurringWarningErrorAtEnd(
                     state,
-                    std::string{RoutineName} + thisDXCoil.DXCoilType + "=\"" + thisDXCoil.Name +
-                        "\": Energy Input Ratio Modifier curve (function of temperature) output is negative warning continues...",
+                    format("{}: {}=\"{}\" - Energy Input Ratio Modifier curve (function of temperature) output is negative warning continues...",
+                           routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                     thisDXCoil.EIRFTempErrorIndex,
                     EIRTempModFac,
                     EIRTempModFac);
@@ -9902,7 +10008,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
             //   Warn user if curve output goes negative
             if (EIRFlowModFac < 0.0) {
                 if (thisDXCoil.EIRFFlowErrorIndex == 0) {
-                    ShowWarningMessage(state, format("{}{}=\"{}\":", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                    ShowWarningMessage(state, format("{}{}=\"{}\":", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowContinueError(
                         state, format(" Energy Input Ratio Modifier curve (function of flow fraction) output is negative ({:.3T}).", EIRFlowModFac));
                     ShowContinueError(state, format(" Negative value occurs using an air flow fraction of {:.3T}.", AirMassFlowRatio));
@@ -9913,8 +10019,8 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 }
                 ShowRecurringWarningErrorAtEnd(
                     state,
-                    std::string{RoutineName} + thisDXCoil.DXCoilType + "=\"" + thisDXCoil.Name +
-                        "\": Energy Input Ratio Modifier curve (function of flow fraction) output is negative warning continues...",
+                    format("{}: {}=\"{}\" - Energy Input Ratio Modifier curve (function of flow fraction) output is negative warning continues...",
+                           routineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                     thisDXCoil.EIRFFlowErrorIndex,
                     EIRFlowModFac,
                     EIRFlowModFac);
@@ -9974,7 +10080,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                                  thisDXCoil.basinHeaterSched,
                                  thisDXCoil.BasinHeaterSetPointTemp,
                                  thisDXCoil.BasinHeaterPower);
-            if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
+            if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                 thisDXCoil.BasinHeaterPower *= (1.0 - thisDXCoil.CoolingCoilRuntimeFraction);
             }
         }
@@ -10011,7 +10117,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
         }
 
         // Calculate basin heater power
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+        if (thisDXCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
             if (any_eq(thisDXCoil.CondenserType, DataHeatBalance::RefrigCondenserType::Evap)) {
                 CalcBasinHeaterPower(state,
                                      thisDXCoil.BasinHeaterPowerFTempDiff,
@@ -10276,8 +10382,8 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
                 ShowContinueError(state, "... Operation at low inlet temperatures may require special performance curves.");
             }
             ShowRecurringWarningErrorAtEnd(state,
-                                           thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                                               "\" - Low condenser inlet temperature error continues...",
+                                           format("{}=\"{}\" - Low condenser inlet temperature error continues...",
+                                                  HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                            thisDXCoil.LowAmbErrIndex,
                                            thisDXCoil.LowTempLast,
                                            thisDXCoil.LowTempLast,
@@ -10295,8 +10401,8 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
                 ShowContinueError(state, "... Operation at high inlet temperatures may require special performance curves.");
             }
             ShowRecurringWarningErrorAtEnd(state,
-                                           thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                                               "\" - High condenser inlet temperature error continues...",
+                                           format("{}=\"{}\" - High condenser inlet temperature error continues...",
+                                                  HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                            thisDXCoil.HighAmbErrIndex,
                                            thisDXCoil.HighTempLast,
                                            thisDXCoil.HighTempLast,
@@ -10320,9 +10426,9 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
                                   "   3) is used as part of a HX assisted cooling coil which uses a high sensible effectiveness. Check inputs.");
             }
             ShowRecurringWarningErrorAtEnd(state,
-                                           thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                                               "\" - Full load outlet temperature indicates a possibility of frost/freeze error continues. "
-                                               "Outlet air temperature statistics follow:",
+                                           format("{}=\"{}\" - Full load outlet temperature indicates a possibility of frost/freeze error continues. "
+                                                  "Outlet air temperature statistics follow:",
+                                                  HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                            thisDXCoil.LowOutletTempIndex,
                                            thisDXCoil.FullLoadOutAirTempLast,
                                            thisDXCoil.FullLoadOutAirTempLast);
@@ -10355,7 +10461,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
         VolFlowperRatedTotCap = AirVolumeFlowRate / thisDXCoil.RatedTotCap(Mode);
 
         if (thisDXCoil.RatedTotCap(Mode) <= 0.0) {
-            ShowFatalError(state, format("{} \"{}\" - Rated total cooling capacity is zero or less.", thisDXCoil.DXCoilType, thisDXCoil.Name));
+            ShowFatalError(state, format("{} \"{}\" - Rated total cooling capacity is zero or less.", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
         }
 
         if (!FirstHVACIteration && !state.dataGlobal->WarmupFlag &&
@@ -10365,7 +10471,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at {:.3R} m3/s/W.",
-                           thisDXCoil.DXCoilType,
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                            thisDXCoil.Name,
                            VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
@@ -10392,8 +10498,8 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                    "\" - Air volume flow rate per watt of rated total cooling capacity is out of range error continues...",
+                format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range error continues...",
+                       HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                 thisDXCoil.ErrIndex1,
                 VolFlowperRatedTotCap,
                 VolFlowperRatedTotCap);
@@ -10420,7 +10526,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             thisDXCoil.LowTempLast = OutdoorDryBulb;
             if (thisDXCoil.LowAmbErrIndex == 0) {
                 thisDXCoil.LowAmbBuffer1 = format("{} \"{}\" - Condenser inlet temperature below {:.2R} C. Condenser inlet temperature = {:.2R}",
-                                                  thisDXCoil.DXCoilType,
+                                                  HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                   thisDXCoil.Name,
                                                   thisDXCoil.MinOATCompressor,
                                                   OutdoorDryBulb);
@@ -10435,7 +10541,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             thisDXCoil.HighTempLast = OutdoorDryBulb;
             if (thisDXCoil.HighAmbErrIndex == 0) {
                 thisDXCoil.HighAmbBuffer1 = format("{} \"{}\" - Condenser inlet temperature above {:.2R} C. Condenser temperature = {:.2R}",
-                                                   thisDXCoil.DXCoilType,
+                                                   HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                    thisDXCoil.Name,
                                                    thisDXCoil.MaxOATCompressor,
                                                    OutdoorDryBulb);
@@ -10462,7 +10568,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
         //  Warn user if curve output goes negative
         if (TotCapTempModFac < 0.0) {
             if (thisDXCoil.CCapFTempErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                 ShowContinueError(
                     state, format(" Total Cooling Capacity Modifier curve (function of temperature) output is negative ({:.3T}).", TotCapTempModFac));
                 ShowContinueError(
@@ -10477,8 +10583,8 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                    "\": Total Cooling Capacity Modifier curve (function of temperature) output is negative warning continues...",
+                format("{}=\"{}\" - Total Cooling Capacity Modifier curve (function of temperature) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                 thisDXCoil.CCapFTempErrorIndex,
                 TotCapTempModFac,
                 TotCapTempModFac);
@@ -10492,7 +10598,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
         //  Warn user if curve output goes negative
         if (TotCapFlowModFac < 0.0) {
             if (thisDXCoil.CCapFFlowErrorIndex == 0) {
-                ShowWarningMessage(state, format("{} \"{}\":", thisDXCoil.DXCoilType, thisDXCoil.Name));
+                ShowWarningMessage(state, format("{} \"{}\":", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                 ShowContinueError(
                     state,
                     format(" Total Cooling Capacity Modifier curve (function of flow fraction) output is negative ({:.3T}).", TotCapFlowModFac));
@@ -10504,8 +10610,8 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                    "\": Total Cooling Capacity Modifier curve (function of flow fraction) output is negative warning continues...",
+                format("{}=\"{}\" - Total Cooling Capacity Modifier curve (function of flow fraction) output is negative warning continues...",
+                       HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                 thisDXCoil.CCapFFlowErrorIndex,
                 TotCapFlowModFac,
                 TotCapFlowModFac);
@@ -10628,7 +10734,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
                 thisDXCoil.FullLoadInletAirTempLast = InletAirDryBulbTemp;
                 thisDXCoil.LowOutTempBuffer1 = format("{} \"{}\" - Full load outlet air dry-bulb temperature < 2C. This indicates the "
                                                       "possibility of coil frost/freeze. Outlet temperature = {:.2R} C.",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       FullLoadOutAirTemp);
                 thisDXCoil.LowOutTempBuffer2 = " ...Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
@@ -10932,7 +11038,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range at {:.3R} m3/s/W.",
-                           thisDXCoil.DXCoilType,
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                            thisDXCoil.Name,
                            VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
@@ -10945,8 +11051,8 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
-                thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                    "\" - Air volume flow rate per watt of rated total heating capacity is out of range error continues...",
+                format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range error continues...",
+                       HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                 thisDXCoil.ErrIndex1,
                 VolFlowperRatedTotCap,
                 VolFlowperRatedTotCap);
@@ -10971,14 +11077,16 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
         } else {
             switch (thisDXCoil.HeatingPerformanceOATType) {
             case HVAC::OATType::DryBulb: {
-                if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating && thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_FluidTCtrl_Heating) {
+                if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRF &&
+                    thisDXCoil.coilType != HVAC::CoilType::HeatingVRFFluidTCtrl) {
                     TotCapTempModFac = CurveValue(state, thisDXCoil.CCapFTemp(Mode), OutdoorDryBulb);
                 } else {
                     TotCapTempModFac = CurveValue(state, thisDXCoil.CCapFTemp(Mode), InletAirDryBulbTemp);
                 }
             } break;
             case HVAC::OATType::WetBulb: {
-                if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating && thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_FluidTCtrl_Heating) {
+                if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRF &&
+                    thisDXCoil.coilType != HVAC::CoilType::HeatingVRFFluidTCtrl) {
                     TotCapTempModFac = CurveValue(state, thisDXCoil.CCapFTemp(Mode), OutdoorWetBulb);
                 } else {
                     TotCapTempModFac = CurveValue(state, thisDXCoil.CCapFTemp(Mode), InletAirDryBulbTemp);
@@ -10997,7 +11105,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
                 ShowContinueError(state,
                                   "TotCapTempModFac curve value must be > 0. TotCapTempModFac curve value has been reset to 0.0 and "
                                   "simulation is continuing.");
-                ShowContinueError(state, format("Check the IO reference manual for TotCapTempModFac curve guidance [ {} ].", thisDXCoil.DXCoilType));
+                ShowContinueError(state, format("Check the IO reference manual for TotCapTempModFac curve guidance [ {} ].", HVAC::coilTypeNames[(int)thisDXCoil.coilType]));
                 ShowContinueErrorTimeStamp(state, "");
             }
             ShowRecurringWarningErrorAtEnd(state,
@@ -11119,7 +11227,8 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
         // Model was extended to accept bi-quadratic curves. This allows sensitivity of the EIR
         // to the entering dry-bulb temperature as well as the outside dry-bulb temperature. User is
         // advised to use the bi-quadratic curve if sufficient manufacturer data is available.
-        if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating && thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_FluidTCtrl_Heating) {
+        if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRF &&
+            thisDXCoil.coilType != HVAC::CoilType::HeatingVRFFluidTCtrl) {
             if (state.dataCurveManager->curves(thisDXCoil.EIRFTemp(Mode))->numDims == 1) {
                 EIRTempModFac = CurveValue(state, thisDXCoil.EIRFTemp(Mode), OutdoorDryBulb);
             } else {
@@ -11136,7 +11245,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
                 ShowWarningMessage(state, format("The EIRTempModFac curve value for DX heating coil {} ={:.2R}", thisDXCoil.Name, EIRTempModFac));
                 ShowContinueError(
                     state, "EIRTempModFac curve value must be > 0.  EIRTempModFac curve value has been reset to 0.0 and simulation is continuing.");
-                ShowContinueError(state, format("Check the IO reference manual for EIRTempModFac curve guidance [ {} ].", thisDXCoil.DXCoilType));
+                ShowContinueError(state, format("Check the IO reference manual for EIRTempModFac curve guidance [ {} ].", HVAC::coilTypeNames[(int)thisDXCoil.coilType]));
                 ShowContinueErrorTimeStamp(state, "");
             }
             ShowRecurringWarningErrorAtEnd(state,
@@ -11154,7 +11263,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
         } else {
             PLRHeating = 0.0;
         }
-        if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating) {
+        if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRF) {
             PLF = CurveValue(state, thisDXCoil.PLFFPLR(Mode), PLRHeating); // Calculate part-load factor
         } else {
             PLF = 1.0;
@@ -11861,7 +11970,7 @@ Real64 AdjustCBF(Real64 const CBFNom,             // nominal coil bypass factor
 }
 
 Real64 CalcCBF(EnergyPlusData &state,
-               std::string const &UnitType,
+               HVAC::CoilType coilType, 
                std::string const &UnitName,
                Real64 const InletAirTemp,   // inlet air temperature [C]
                Real64 const InletAirHumRat, // inlet air humidity ratio [kg water / kg dry air]
@@ -11939,7 +12048,7 @@ Real64 CalcCBF(EnergyPlusData &state,
     //  Pressure will have to be pass into this subroutine to fix this one
     OutletAirRH = PsyRhFnTdbWPb(state, OutletAirTemp, OutletAirHumRat, DataEnvironment::StdPressureSeaLevel, RoutineName);
     if (OutletAirRH >= 1.0 && PrintFlag) {
-        ShowWarningError(state, format("For object = {}, name = \"{}\"", UnitType, UnitName));
+        ShowWarningError(state, format("For object = {}, name = \"{}\"", HVAC::coilTypeNames[(int)coilType], UnitName));
         ShowContinueError(state, "Calculated outlet air relative humidity greater than 1. The combination of");
         ShowContinueError(state, "rated air volume flow rate, total cooling capacity and sensible heat ratio yields coil exiting");
         ShowContinueError(state, "air conditions above the saturation curve. Possible fixes are to reduce the rated total cooling");
@@ -11976,7 +12085,7 @@ Real64 CalcCBF(EnergyPlusData &state,
     }
     DeltaT = InletAirTemp - OutletAirTemp;
     if (DeltaT <= 0.0) {
-        ShowSevereError(state, format("For object = {}, name = \"{}\"", UnitType, UnitName));
+        ShowSevereError(state, format("For object = {}, name = \"{}\"", HVAC::coilTypeNames[(int)coilType], UnitName));
         ShowContinueError(state, "Calculated coil delta T is less than or equal to 0. The combination of");
         ShowContinueError(state, "rated air volume flow rate, total cooling capacity and sensible heat ratio yields coil exiting");
         ShowContinueError(state, "air conditions that are not reasonable. Possible fixes are to adjust the rated total cooling");
@@ -12008,7 +12117,7 @@ Real64 CalcCBF(EnergyPlusData &state,
     if (SlopeAtConds < 0.0 || OutletAirHumRat <= 0.0) {
         //   Invalid conditions, slope can't be less than zero (SHR > 1) or
         //   outlet air humidity ratio can't be less than zero.
-        ShowSevereError(state, format("{} \"{}\"", UnitType, UnitName));
+        ShowSevereError(state, format("{} \"{}\"", HVAC::coilTypeNames[(int)coilType], UnitName));
         ShowContinueError(state, "...Invalid slope or outlet air condition when calculating cooling coil bypass factor.");
         ShowContinueError(state, format("...Slope = {:.8R}", SlopeAtConds));
         ShowContinueError(state, format("...Inlet Air Temperature     = {:.2R} C", InletAirTemp));
@@ -12074,7 +12183,7 @@ Real64 CalcCBF(EnergyPlusData &state,
         ADPEnthalpy = PsyHFnTdbW(ADPTemp, ADPHumRat);
         CBF = min(1.0, (OutletAirEnthalpy - ADPEnthalpy) / (InletAirEnthalpy - ADPEnthalpy));
         if (Iter > IterMax && PrintFlag) {
-            ShowSevereError(state, format("{} \"{}\" -- coil bypass factor calculation did not converge after max iterations.", UnitType, UnitName));
+          ShowSevereError(state, format("{} \"{}\" -- coil bypass factor calculation did not converge after max iterations.", HVAC::coilTypeNames[(int)coilType], UnitName));
             ShowContinueError(state, format("The RatedSHR of [{:.3R}], entered by the user or autosized (see *.eio file),", SHR));
             ShowContinueError(state, "may be causing this. The line defined by the coil rated inlet air conditions");
             ShowContinueError(state, "(26.7C drybulb and 19.4C wetbulb) and the RatedSHR (i.e., slope of the line) must intersect");
@@ -12088,7 +12197,7 @@ Real64 CalcCBF(EnergyPlusData &state,
             CBFErrors = true; // Didn't converge within MaxIter iterations
         }
         if (CBF < 0.0 && PrintFlag) {
-            ShowSevereError(state, format("{} \"{}\" -- negative coil bypass factor calculated.", UnitType, UnitName));
+            ShowSevereError(state, format("{} \"{}\" -- negative coil bypass factor calculated.", HVAC::coilTypeNames[(int)coilType], UnitName));
             ShowContinueErrorTimeStamp(state, "");
             CBFErrors = true; // Negative CBF not valid
         }
@@ -12096,14 +12205,14 @@ Real64 CalcCBF(EnergyPlusData &state,
 
     // Show fatal error for specific coil that caused a CBF error
     if (CBFErrors) {
-        ShowFatalError(state, format("{} \"{}\" Errors found in calculating coil bypass factors", UnitType, UnitName));
+      ShowFatalError(state, format("{} \"{}\" Errors found in calculating coil bypass factors", HVAC::coilTypeNames[(int)coilType], UnitName));
     }
 
     return CBF;
 }
 
 Real64 ValidateADP(EnergyPlusData &state,
-                   std::string const &UnitType,      // component name
+                   HVAC::CoilType coilType,      // component name
                    std::string const &UnitName,      // component type
                    Real64 const RatedInletAirTemp,   // coil inlet air temperature [C]
                    Real64 const RatedInletAirHumRat, // coil inlet air humidity ratio [kg/kg]
@@ -12157,7 +12266,7 @@ Real64 ValidateADP(EnergyPlusData &state,
     AirMassFlow =
         AirVolFlowRate * PsyRhoAirFnPbTdbW(state, DataEnvironment::StdPressureSeaLevel, RatedInletAirTemp, RatedInletAirHumRat, CallingRoutine);
     while (bStillValidating) {
-        CBF_calculated = max(0.0, CalcCBF(state, UnitType, UnitName, RatedInletAirTemp, RatedInletAirHumRat, TotCap, AirMassFlow, SHR, bNoReporting));
+        CBF_calculated = max(0.0, CalcCBF(state, coilType, UnitName, RatedInletAirTemp, RatedInletAirHumRat, TotCap, AirMassFlow, SHR, bNoReporting));
         DeltaH = TotCap / AirMassFlow;
         InletAirEnthalpy = PsyHFnTdbW(RatedInletAirTemp, RatedInletAirHumRat);
         HTinHumRatOut = InletAirEnthalpy - (1.0 - SHR) * DeltaH;
@@ -12264,7 +12373,7 @@ Real64 CalcEffectiveSHR(EnergyPlusData &state,
 
     auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
 
-    if (thisDXCoil.DXCoilType_Num != HVAC::CoilDX_MultiSpeedCooling) {
+    if (thisDXCoil.coilType != HVAC::CoilType::CoolingDXMultiSpeed) {
         Twet_Rated = thisDXCoil.Twet_Rated(Mode);
         Gamma_Rated = thisDXCoil.Gamma_Rated(Mode);
         Nmax = thisDXCoil.MaxONOFFCyclesperHour(Mode);
@@ -12648,7 +12757,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
     if ((AirMassFlow > 0.0) && (CycRatio > 0.0) && (MSHPMassFlowRateHigh == 0.0)) {
         ShowSevereError(
             state,
-            format("CalcMultiSpeedDXCoilCooling: {} \"{} Developer error - inconsistent airflow rates.", thisDXCoil.DXCoilType, thisDXCoil.Name));
+            format("CalcMultiSpeedDXCoilCooling: {} \"{} Developer error - inconsistent airflow rates.", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
         if (MSHPMassFlowRateLow == 0.0 && SpeedNum > 1) {
             ShowContinueError(state,
                               "When AirMassFlow > 0.0 and CycRatio > 0.0 and SpeedNum > 1, then MSHPMassFlowRateLow and MSHPMassFlowRateHigh "
@@ -12672,7 +12781,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
     } else if (CycRatio > 1.0 || SpeedRatio > 1.0) {
         ShowSevereError(
             state,
-            format("CalcMultiSpeedDXCoilCooling: {} \"{} Developer error - inconsistent speed ratios.", thisDXCoil.DXCoilType, thisDXCoil.Name));
+            format("CalcMultiSpeedDXCoilCooling: {} \"{} Developer error - inconsistent speed ratios.", HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
         ShowContinueError(state, "CycRatio and SpeedRatio must be between 0.0 and 1.0");
         ShowContinueErrorTimeStamp(state, "");
         ShowContinueError(state, format("CycRatio={:.1R}, SpeedRatio = {:.1R}", CycRatio, SpeedRatio));
@@ -12723,7 +12832,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at speed {}.",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                SpeedNumLS));
                     ShowContinueErrorTimeStamp(state, "");
@@ -12738,7 +12847,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                 ShowRecurringWarningErrorAtEnd(state,
                                                format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range "
                                                       "at speed {} error continues...",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       SpeedNumLS),
                                                thisDXCoil.MSErrIndex(SpeedNumLS),
@@ -12758,7 +12867,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at speed {}.",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                SpeedNumHS));
                     ShowContinueErrorTimeStamp(state, "");
@@ -12773,7 +12882,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                 ShowRecurringWarningErrorAtEnd(state,
                                                format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range "
                                                       "at speed {} error continues...",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       SpeedNumHS),
                                                thisDXCoil.MSErrIndex(SpeedNumHS),
@@ -13061,7 +13170,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at speed {}.",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                SpeedNum));
                     ShowContinueErrorTimeStamp(state, "");
@@ -13076,7 +13185,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                 ShowRecurringWarningErrorAtEnd(state,
                                                format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range "
                                                       "at speed {} error continues...",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       SpeedNumHS),
                                                thisDXCoil.MSErrIndex(SpeedNumHS),
@@ -13458,7 +13567,8 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
     if ((AirMassFlow > 0.0) && (CycRatio > 0.0) && (MSHPMassFlowRateHigh == 0.0)) {
         ShowSevereError(
             state,
-            format("CalcMultiSpeedDXCoilHeating: {} \"{} Developer error - inconsistent airflow rates.", thisDXCoil.DXCoilType, thisDXCoil.Name));
+            format("CalcMultiSpeedDXCoilHeating: {} \"{} Developer error - inconsistent airflow rates.",
+                   HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
         if (MSHPMassFlowRateLow == 0.0 && SpeedNum > 1) {
             ShowContinueError(state,
                               "When AirMassFlow > 0.0 and CycRatio > 0.0 and SpeedNum > 1, then MSHPMassFlowRateLow and MSHPMassFlowRateHigh "
@@ -13482,7 +13592,8 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
     } else if (CycRatio > 1.0 || SpeedRatio > 1.0) {
         ShowSevereError(
             state,
-            format("CalcMultiSpeedDXCoilHeating: {} \"{} Developer error - inconsistent speed ratios.", thisDXCoil.DXCoilType, thisDXCoil.Name));
+            format("CalcMultiSpeedDXCoilHeating: {} \"{} Developer error - inconsistent speed ratios.",
+                   HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
         ShowContinueError(state, "CycRatio and SpeedRatio must be between 0.0 and 1.0");
         ShowContinueErrorTimeStamp(state, "");
         ShowContinueError(state, format("CycRatio={:.1R}, SpeedRatio = {:.1R}", CycRatio, SpeedRatio));
@@ -13560,7 +13671,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range at speed {}.",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                SpeedNumLS));
                     ShowContinueErrorTimeStamp(state, "");
@@ -13575,7 +13686,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                 ShowRecurringWarningErrorAtEnd(state,
                                                format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range "
                                                       "at speed {} error continues...",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       SpeedNumLS),
                                                thisDXCoil.MSErrIndex(SpeedNumLS),
@@ -13594,7 +13705,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range at speed {}.",
-                               thisDXCoil.DXCoilType,
+                               HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                thisDXCoil.Name,
                                SpeedNumHS));
                     ShowContinueErrorTimeStamp(state, "");
@@ -13609,7 +13720,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                 ShowRecurringWarningErrorAtEnd(state,
                                                format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range "
                                                       "at speed {} error continues...",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       SpeedNumHS),
                                                thisDXCoil.MSErrIndex(SpeedNumHS),
@@ -13867,7 +13978,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                 if (thisDXCoil.ErrIndex1 == 0) {
                     ShowWarningMessage(state,
                                        format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range at speed 1.",
-                                              thisDXCoil.DXCoilType,
+                                              HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                               thisDXCoil.Name));
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(state,
@@ -13880,8 +13991,9 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                 }
                 ShowRecurringWarningErrorAtEnd(
                     state,
-                    thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                        "\" - Air volume flow rate per watt of rated total heating capacity is out of range error continues at speed 1...",
+                    format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range error continues at speed 1...",
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
+
                     thisDXCoil.ErrIndex1,
                     VolFlowperRatedTotCap,
                     VolFlowperRatedTotCap);
@@ -14193,110 +14305,113 @@ void ReportDXCoil(EnergyPlusData &state, int const DXCoilNum) // number of the c
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
 
-    auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
+    auto &dxCoil = state.dataDXCoils->DXCoil(DXCoilNum);
 
-    if (thisDXCoil.reportCoilFinalSizes) {
+    if (dxCoil.reportCoilFinalSizes) {
         if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
             Real64 ratedSensCap(0.0);
-            ratedSensCap = thisDXCoil.RatedTotCap(1) * thisDXCoil.RatedSHR(1);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(
-                state, thisDXCoil.Name, thisDXCoil.DXCoilType, thisDXCoil.RatedTotCap(1), ratedSensCap, thisDXCoil.RatedAirVolFlowRate(1), -999.0);
-            thisDXCoil.reportCoilFinalSizes = false;
+            ratedSensCap = dxCoil.RatedTotCap(1) * dxCoil.RatedSHR(1);
+            ReportCoilSelection::setCoilFinalSizes(
+                state, dxCoil.Name, dxCoil.coilType, dxCoil.RatedTotCap(1), ratedSensCap, dxCoil.RatedAirVolFlowRate(1), -999.0);
+            dxCoil.reportCoilFinalSizes = false;
         }
     }
 
     Real64 ReportingConstant = state.dataHVACGlobal->TimeStepSysSec;
 
-    switch (thisDXCoil.DXCoilType_Num) {
-    case HVAC::CoilDX_HeatingEmpirical:
-    case HVAC::CoilVRF_Heating:
-    case HVAC::CoilVRF_FluidTCtrl_Heating: {
-        thisDXCoil.TotalHeatingEnergy = thisDXCoil.TotalHeatingEnergyRate * ReportingConstant;
-        thisDXCoil.ElecHeatingConsumption = thisDXCoil.ElecHeatingPower * ReportingConstant;
-        thisDXCoil.DefrostConsumption = thisDXCoil.DefrostPower * ReportingConstant;
-        thisDXCoil.CrankcaseHeaterConsumption = thisDXCoil.CrankcaseHeaterPower * ReportingConstant;
-        state.dataHVACGlobal->DXElecHeatingPower = thisDXCoil.ElecHeatingPower + thisDXCoil.CrankcaseHeaterPower;
-        state.dataHVACGlobal->DefrostElecPower = thisDXCoil.DefrostPower;
+    switch (dxCoil.coilType) {
+    case HVAC::CoilType::HeatingDXSingleSpeed:
+    case HVAC::CoilType::HeatingVRF:
+    case HVAC::CoilType::HeatingVRFFluidTCtrl: {
+        dxCoil.TotalHeatingEnergy = dxCoil.TotalHeatingEnergyRate * ReportingConstant;
+        dxCoil.ElecHeatingConsumption = dxCoil.ElecHeatingPower * ReportingConstant;
+        dxCoil.DefrostConsumption = dxCoil.DefrostPower * ReportingConstant;
+        dxCoil.CrankcaseHeaterConsumption = dxCoil.CrankcaseHeaterPower * ReportingConstant;
+        state.dataHVACGlobal->DXElecHeatingPower = dxCoil.ElecHeatingPower + dxCoil.CrankcaseHeaterPower;
+        state.dataHVACGlobal->DefrostElecPower = dxCoil.DefrostPower;
     } break;
-    case HVAC::CoilDX_MultiSpeedHeating: {
-        thisDXCoil.TotalHeatingEnergy = thisDXCoil.TotalHeatingEnergyRate * ReportingConstant;
-        if (thisDXCoil.FuelType == Constant::eFuel::Electricity) {
-            thisDXCoil.ElecHeatingConsumption = thisDXCoil.ElecHeatingPower * ReportingConstant;
+
+    case HVAC::CoilType::HeatingDXMultiSpeed: {
+        dxCoil.TotalHeatingEnergy = dxCoil.TotalHeatingEnergyRate * ReportingConstant;
+        if (dxCoil.FuelType == Constant::eFuel::Electricity) {
+            dxCoil.ElecHeatingConsumption = dxCoil.ElecHeatingPower * ReportingConstant;
         } else {
-            thisDXCoil.FuelConsumed = thisDXCoil.FuelUsed * ReportingConstant;
+            dxCoil.FuelConsumed = dxCoil.FuelUsed * ReportingConstant;
         }
-        thisDXCoil.DefrostConsumption = thisDXCoil.DefrostPower * ReportingConstant;
-        thisDXCoil.CrankcaseHeaterConsumption = thisDXCoil.CrankcaseHeaterPower * ReportingConstant;
-        state.dataHVACGlobal->DXElecHeatingPower = thisDXCoil.ElecHeatingPower + thisDXCoil.CrankcaseHeaterPower;
-        state.dataHVACGlobal->DefrostElecPower = thisDXCoil.DefrostPower;
+        dxCoil.DefrostConsumption = dxCoil.DefrostPower * ReportingConstant;
+        dxCoil.CrankcaseHeaterConsumption = dxCoil.CrankcaseHeaterPower * ReportingConstant;
+        state.dataHVACGlobal->DXElecHeatingPower = dxCoil.ElecHeatingPower + dxCoil.CrankcaseHeaterPower;
+        state.dataHVACGlobal->DefrostElecPower = dxCoil.DefrostPower;
     } break;
-    case HVAC::CoilDX_MultiSpeedCooling: {
-        thisDXCoil.TotalCoolingEnergy = thisDXCoil.TotalCoolingEnergyRate * ReportingConstant;
-        thisDXCoil.SensCoolingEnergy = thisDXCoil.SensCoolingEnergyRate * ReportingConstant;
-        thisDXCoil.LatCoolingEnergy = thisDXCoil.TotalCoolingEnergy - thisDXCoil.SensCoolingEnergy;
-        thisDXCoil.CrankcaseHeaterConsumption = thisDXCoil.CrankcaseHeaterPower * ReportingConstant;
-        state.dataHVACGlobal->DXElecCoolingPower = thisDXCoil.ElecCoolingPower;
-        thisDXCoil.EvapCondPumpElecConsumption = thisDXCoil.EvapCondPumpElecPower * ReportingConstant;
-        thisDXCoil.EvapWaterConsump = thisDXCoil.EvapWaterConsumpRate * ReportingConstant;
-        if (thisDXCoil.FuelType == Constant::eFuel::Electricity) {
-            thisDXCoil.ElecCoolingConsumption = thisDXCoil.ElecCoolingPower * ReportingConstant;
+
+    case HVAC::CoilType::CoolingDXMultiSpeed: {
+        dxCoil.TotalCoolingEnergy = dxCoil.TotalCoolingEnergyRate * ReportingConstant;
+        dxCoil.SensCoolingEnergy = dxCoil.SensCoolingEnergyRate * ReportingConstant;
+        dxCoil.LatCoolingEnergy = dxCoil.TotalCoolingEnergy - dxCoil.SensCoolingEnergy;
+        dxCoil.CrankcaseHeaterConsumption = dxCoil.CrankcaseHeaterPower * ReportingConstant;
+        state.dataHVACGlobal->DXElecCoolingPower = dxCoil.ElecCoolingPower;
+        dxCoil.EvapCondPumpElecConsumption = dxCoil.EvapCondPumpElecPower * ReportingConstant;
+        dxCoil.EvapWaterConsump = dxCoil.EvapWaterConsumpRate * ReportingConstant;
+        if (dxCoil.FuelType == Constant::eFuel::Electricity) {
+            dxCoil.ElecCoolingConsumption = dxCoil.ElecCoolingPower * ReportingConstant;
         } else {
-            thisDXCoil.FuelConsumed = thisDXCoil.FuelUsed * ReportingConstant;
+            dxCoil.FuelConsumed = dxCoil.FuelUsed * ReportingConstant;
         }
-        if (any_eq(thisDXCoil.CondenserType, DataHeatBalance::RefrigCondenserType::Evap)) {
-            thisDXCoil.BasinHeaterConsumption = thisDXCoil.BasinHeaterPower * ReportingConstant;
+        if (any_eq(dxCoil.CondenserType, DataHeatBalance::RefrigCondenserType::Evap)) {
+            dxCoil.BasinHeaterConsumption = dxCoil.BasinHeaterPower * ReportingConstant;
         }
     } break;
-    case HVAC::CoilDX_HeatPumpWaterHeaterPumped:
-    case HVAC::CoilDX_HeatPumpWaterHeaterWrapped: {
+
+    case HVAC::CoilType::WaterHeatingDXPumped:
+    case HVAC::CoilType::WaterHeatingDXWrapped: {
         // water heating energy for HP water heater DX Coil condenser
-        thisDXCoil.TotalHeatingEnergy = thisDXCoil.TotalHeatingEnergyRate * ReportingConstant;
+        dxCoil.TotalHeatingEnergy = dxCoil.TotalHeatingEnergyRate * ReportingConstant;
         // water heating power for HP water heater
-        thisDXCoil.ElecWaterHeatingConsumption = thisDXCoil.ElecWaterHeatingPower * ReportingConstant;
+        dxCoil.ElecWaterHeatingConsumption = dxCoil.ElecWaterHeatingPower * ReportingConstant;
         // other usual DX cooling coil outputs
-        thisDXCoil.TotalCoolingEnergy = thisDXCoil.TotalCoolingEnergyRate * ReportingConstant;
-        thisDXCoil.SensCoolingEnergy = thisDXCoil.SensCoolingEnergyRate * ReportingConstant;
-        thisDXCoil.LatCoolingEnergy = thisDXCoil.TotalCoolingEnergy - thisDXCoil.SensCoolingEnergy;
-        thisDXCoil.ElecCoolingConsumption = thisDXCoil.ElecCoolingPower * ReportingConstant;
-        thisDXCoil.CrankcaseHeaterConsumption = thisDXCoil.CrankcaseHeaterPower * ReportingConstant;
+        dxCoil.TotalCoolingEnergy = dxCoil.TotalCoolingEnergyRate * ReportingConstant;
+        dxCoil.SensCoolingEnergy = dxCoil.SensCoolingEnergyRate * ReportingConstant;
+        dxCoil.LatCoolingEnergy = dxCoil.TotalCoolingEnergy - dxCoil.SensCoolingEnergy;
+        dxCoil.ElecCoolingConsumption = dxCoil.ElecCoolingPower * ReportingConstant;
+        dxCoil.CrankcaseHeaterConsumption = dxCoil.CrankcaseHeaterPower * ReportingConstant;
         // DXElecCoolingPower global is only used for air-to-air cooling and heating coils
         state.dataHVACGlobal->DXElecCoolingPower = 0.0;
     } break;
     default: {
-        thisDXCoil.TotalCoolingEnergy = thisDXCoil.TotalCoolingEnergyRate * ReportingConstant;
-        thisDXCoil.SensCoolingEnergy = thisDXCoil.SensCoolingEnergyRate * ReportingConstant;
-        thisDXCoil.LatCoolingEnergy = thisDXCoil.TotalCoolingEnergy - thisDXCoil.SensCoolingEnergy;
-        thisDXCoil.ElecCoolingConsumption = thisDXCoil.ElecCoolingPower * ReportingConstant;
-        thisDXCoil.CrankcaseHeaterConsumption = thisDXCoil.CrankcaseHeaterPower * ReportingConstant;
-        state.dataHVACGlobal->DXElecCoolingPower = thisDXCoil.ElecCoolingPower;
-        thisDXCoil.EvapCondPumpElecConsumption = thisDXCoil.EvapCondPumpElecPower * ReportingConstant;
-        thisDXCoil.EvapWaterConsump = thisDXCoil.EvapWaterConsumpRate * ReportingConstant;
-        if (any_eq(thisDXCoil.CondenserType, DataHeatBalance::RefrigCondenserType::Evap)) {
-            thisDXCoil.BasinHeaterConsumption = thisDXCoil.BasinHeaterPower * ReportingConstant;
+        dxCoil.TotalCoolingEnergy = dxCoil.TotalCoolingEnergyRate * ReportingConstant;
+        dxCoil.SensCoolingEnergy = dxCoil.SensCoolingEnergyRate * ReportingConstant;
+        dxCoil.LatCoolingEnergy = dxCoil.TotalCoolingEnergy - dxCoil.SensCoolingEnergy;
+        dxCoil.ElecCoolingConsumption = dxCoil.ElecCoolingPower * ReportingConstant;
+        dxCoil.CrankcaseHeaterConsumption = dxCoil.CrankcaseHeaterPower * ReportingConstant;
+        state.dataHVACGlobal->DXElecCoolingPower = dxCoil.ElecCoolingPower;
+        dxCoil.EvapCondPumpElecConsumption = dxCoil.EvapCondPumpElecPower * ReportingConstant;
+        dxCoil.EvapWaterConsump = dxCoil.EvapWaterConsumpRate * ReportingConstant;
+        if (any_eq(dxCoil.CondenserType, DataHeatBalance::RefrigCondenserType::Evap)) {
+            dxCoil.BasinHeaterConsumption = dxCoil.BasinHeaterPower * ReportingConstant;
         }
     } break;
     }
 
-    if (thisDXCoil.CondensateCollectMode == CondensateCollectAction::ToTank) {
+    if (dxCoil.CondensateCollectMode == CondensateCollectAction::ToTank) {
         // calculate and report condensation rates  (how much water extracted from the air stream)
         // water flow of water in m3/s for water system interactions
         //  put here to catch all types of DX coils
-        Real64 Tavg = (thisDXCoil.InletAirTemp + thisDXCoil.OutletAirTemp) / 2.0;
+        Real64 Tavg = (dxCoil.InletAirTemp + dxCoil.OutletAirTemp) / 2.0;
         // CR9155 Remove specific humidity calculations
         //  mdot * del HumRat / rho water
-        thisDXCoil.CondensateVdot =
-            max(0.0, (thisDXCoil.InletAirMassFlowRate * (thisDXCoil.InletAirHumRat - thisDXCoil.OutletAirHumRat) / Psychrometrics::RhoH2O(Tavg)));
-        thisDXCoil.CondensateVol = thisDXCoil.CondensateVdot * ReportingConstant;
+        dxCoil.CondensateVdot =
+            max(0.0, (dxCoil.InletAirMassFlowRate * (dxCoil.InletAirHumRat - dxCoil.OutletAirHumRat) / Psychrometrics::RhoH2O(Tavg)));
+        dxCoil.CondensateVol = dxCoil.CondensateVdot * ReportingConstant;
 
-        state.dataWaterData->WaterStorage(thisDXCoil.CondensateTankID).VdotAvailSupply(thisDXCoil.CondensateTankSupplyARRID) =
-            thisDXCoil.CondensateVdot;
-        state.dataWaterData->WaterStorage(thisDXCoil.CondensateTankID).TwaterSupply(thisDXCoil.CondensateTankSupplyARRID) = thisDXCoil.OutletAirTemp;
+        state.dataWaterData->WaterStorage(dxCoil.CondensateTankID).VdotAvailSupply(dxCoil.CondensateTankSupplyARRID) =
+            dxCoil.CondensateVdot;
+        state.dataWaterData->WaterStorage(dxCoil.CondensateTankID).TwaterSupply(dxCoil.CondensateTankSupplyARRID) = dxCoil.OutletAirTemp;
     }
 
-    state.dataAirLoop->LoopDXCoilRTF = max(thisDXCoil.CoolingCoilRuntimeFraction, thisDXCoil.HeatingCoilRuntimeFraction);
-    if (thisDXCoil.AirLoopNum > 0) {
-        state.dataAirLoop->AirLoopAFNInfo(thisDXCoil.AirLoopNum).AFNLoopDXCoilRTF =
-            max(thisDXCoil.CoolingCoilRuntimeFraction, thisDXCoil.HeatingCoilRuntimeFraction);
+    state.dataAirLoop->LoopDXCoilRTF = max(dxCoil.CoolingCoilRuntimeFraction, dxCoil.HeatingCoilRuntimeFraction);
+    if (dxCoil.AirLoopNum > 0) {
+        state.dataAirLoop->AirLoopAFNInfo(dxCoil.AirLoopNum).AFNLoopDXCoilRTF =
+            max(dxCoil.CoolingCoilRuntimeFraction, dxCoil.HeatingCoilRuntimeFraction);
     }
 }
 
@@ -14674,7 +14789,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
             //    Warn user if curve output goes negative
             if (TotCapFlowModFac < 0.0) {
                 if (thisDXCoil.CCapFFlowErrorIndex == 0) {
-                    ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                  ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowContinueError(
                         state,
                         format(" Total Cooling Capacity Modifier curve (function of flow fraction) output is negative ({:.3T}).", TotCapFlowModFac));
@@ -14685,7 +14800,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
                     state,
                     format("{}{}\"{}\": Total Cooling Capacity Modifier curve (function of flow fraction) output is negative warning continues...",
                            RoutineName,
-                           thisDXCoil.DXCoilType,
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                            thisDXCoil.Name),
                     thisDXCoil.CCapFFlowErrorIndex,
                     TotCapFlowModFac,
@@ -14698,7 +14813,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
             //    Warn user if curve output goes negative
             if (TotCapTempModFac < 0.0) {
                 if (thisDXCoil.CCapFTempErrorIndex == 0) {
-                    ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                  ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowContinueError(
                         state,
                         format(" Total Cooling Capacity Modifier curve (function of temperature) output is negative ({:.3T}).", TotCapTempModFac));
@@ -14713,7 +14828,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
                     state,
                     format("{}{} \"{}\": Total Cooling Capacity Modifier curve (function of temperature) output is negative warning continues...",
                            RoutineName,
-                           thisDXCoil.DXCoilType,
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                            thisDXCoil.Name),
                     thisDXCoil.CCapFTempErrorIndex,
                     TotCapTempModFac,
@@ -14740,7 +14855,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
             //    Warn user if curve output goes negative
             if (TotCapTempModFac < 0.0) {
                 if (thisDXCoil.CCapFTempErrorIndex == 0) {
-                    ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, thisDXCoil.DXCoilType, thisDXCoil.Name));
+                  ShowWarningMessage(state, format("{}{} \"{}\":", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
                     ShowContinueError(
                         state,
                         format(" Total Cooling Capacity Modifier curve (function of temperature) output is negative ({:.3T}).", TotCapTempModFac));
@@ -14755,7 +14870,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
                     state,
                     format("{}{} \"{}\": Total Cooling Capacity Modifier curve (function of temperature) output is negative warning continues...",
                            RoutineName,
-                           thisDXCoil.DXCoilType,
+                           HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                            thisDXCoil.Name),
                     thisDXCoil.CCapFTempErrorIndex,
                     TotCapTempModFac,
@@ -14851,7 +14966,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
         for (index = 1; index <= state.dataDXCoils->NumDXCoils; ++index) {
 
             if (state.dataDXCoils->DXCoil(index).RateWithInternalStaticAndFanObject &&
-                state.dataDXCoils->DXCoil(index).DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                state.dataDXCoils->DXCoil(index).coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 ++countStaticInputs;
             }
         }
@@ -14992,27 +15107,23 @@ void GetFanIndexForTwoSpeedCoil(
     FoundAirSysNum = 0;
     SupplyFanIndex = 0;
     SupplyFanName = "n/a";
-    for (AirSysNum = 1; AirSysNum <= NumPrimaryAirSys; ++AirSysNum) {
-
-        for (BranchNum = 1; BranchNum <= state.dataAirSystemsData->PrimaryAirSystems(AirSysNum).NumBranches; ++BranchNum) {
-
-            for (CompNum = 1; CompNum <= state.dataAirSystemsData->PrimaryAirSystems(AirSysNum).Branch(BranchNum).TotalComponents; ++CompNum) {
-
-                if (state.dataAirSystemsData->PrimaryAirSystems(AirSysNum).Branch(BranchNum).Comp(CompNum).CompType_Num ==
-                    SimAirServingZones::CompType::DXSystem) {
-
-                    if (Util::SameString(state.dataAirSystemsData->PrimaryAirSystems(AirSysNum).Branch(BranchNum).Comp(CompNum).Name,
-                                         state.dataDXCoils->DXCoil(CoolingCoilIndex).CoilSystemName)) {
+    for (int AirSysNum = 1; AirSysNum <= NumPrimaryAirSys; ++AirSysNum) {
+        auto const &airSys = state.dataAirSystemsData->PrimaryAirSystems(AirSysNum);
+        for (int BranchNum = 1; BranchNum <= airSys.NumBranches; ++BranchNum) {
+            auto const &branch = airSys.Branch(BranchNum);
+            for (int CompNum = 1; CompNum <= branch.TotalComponents; ++CompNum) {
+                auto const &comp = branch.Comp(CompNum);
+                if (comp.compType == SimAirServingZones::CompType::DXSystem) {
+
+                    if (Util::SameString(comp.Name, state.dataDXCoils->DXCoil(CoolingCoilIndex).CoilSystemName)) {
                         FoundBranch = BranchNum;
                         FoundAirSysNum = AirSysNum;
                         break;
                     }
                     // these are specified in SimAirServingZones and need to be moved to a Data* file. UnitarySystem=19
-                } else if (state.dataAirSystemsData->PrimaryAirSystems(AirSysNum).Branch(BranchNum).Comp(CompNum).CompType_Num ==
-                           SimAirServingZones::CompType::UnitarySystemModel) {
+                } else if (comp.compType == SimAirServingZones::CompType::UnitarySystemModel) {
 
-                    if (Util::SameString(state.dataAirSystemsData->PrimaryAirSystems(AirSysNum).Branch(BranchNum).Comp(CompNum).Name,
-                                         state.dataDXCoils->DXCoil(CoolingCoilIndex).CoilSystemName)) {
+                    if (Util::SameString(comp.Name, state.dataDXCoils->DXCoil(CoolingCoilIndex).CoilSystemName)) {
                         FoundBranch = BranchNum;
                         FoundAirSysNum = AirSysNum;
                         break;
@@ -15021,23 +15132,21 @@ void GetFanIndexForTwoSpeedCoil(
             }
 
             if (FoundBranch > 0 && FoundAirSysNum > 0) {
-                for (CompNum = 1; CompNum <= state.dataAirSystemsData->PrimaryAirSystems(FoundAirSysNum).Branch(FoundBranch).TotalComponents;
-                     ++CompNum) {
-                    if (state.dataAirSystemsData->PrimaryAirSystems(FoundAirSysNum).Branch(FoundBranch).Comp(CompNum).CompType_Num ==
-                        SimAirServingZones::CompType::Fan_Simple_VAV) {
-                        SupplyFanName = state.dataAirSystemsData->PrimaryAirSystems(FoundAirSysNum).Branch(FoundBranch).Comp(CompNum).Name;
+                auto const &foundBranch = state.dataAirSystemsData->PrimaryAirSystems(FoundAirSysNum).Branch(FoundBranch);
+                for (int CompNum = 1; CompNum <= foundBranch.TotalComponents; ++CompNum) {
+                    auto const &comp = foundBranch.Comp(CompNum);
+                    if (comp.compType == SimAirServingZones::CompType::Fan_Simple_VAV) {
+                        SupplyFanName = comp.Name;
                         SupplyFanIndex = Fans::GetFanIndex(state, SupplyFanName);
                         supplyFanType = HVAC::FanType::VAV;
                         break;
                         // these are specified in SimAirServingZones and need to be moved to a Data* file. UnitarySystem=19
-                    } else if (state.dataAirSystemsData->PrimaryAirSystems(FoundAirSysNum).Branch(FoundBranch).Comp(CompNum).CompType_Num ==
-                               SimAirServingZones::CompType::Fan_System_Object) {
-                        SupplyFanName = state.dataAirSystemsData->PrimaryAirSystems(FoundAirSysNum).Branch(FoundBranch).Comp(CompNum).Name;
+                    } else if (comp.compType == SimAirServingZones::CompType::Fan_System_Object) {
+                        SupplyFanName = comp.Name;
                         SupplyFanIndex = Fans::GetFanIndex(state, SupplyFanName);
                         supplyFanType = HVAC::FanType::SystemModel;
 
-                    } else if (state.dataAirSystemsData->PrimaryAirSystems(FoundAirSysNum).Branch(FoundBranch).Comp(CompNum).CompType_Num ==
-                               SimAirServingZones::CompType::UnitarySystemModel) {
+                    } else if (comp.compType == SimAirServingZones::CompType::UnitarySystemModel) {
                         // fan may not be specified in a unitary system object, keep looking
                         // Unitary System will "set" the fan index to the DX coil if contained within the HVAC system
                         if (state.dataDXCoils->DXCoil(CoolingCoilIndex).SupplyFanIndex > 0) break;
@@ -15083,6 +15192,17 @@ void GetDXCoilIndex(EnergyPlusData &state,
     }
 }
 
+int GetCoilIndex(EnergyPlusData &state, std::string const &coilName)
+{
+    if (state.dataDXCoils->GetCoilsInputFlag) {
+        GetDXCoils(state);
+        state.dataDXCoils->GetCoilsInputFlag = false;
+    }
+
+    return Util::FindItemInList(coilName, state.dataDXCoils->DXCoil);
+}
+
+#ifdef OLD_API
 std::string
 GetDXCoilName(EnergyPlusData &state, int &DXCoilIndex, bool &ErrorsFound, std::string_view const ThisObjectType, bool const SuppressWarning)
 {
@@ -15181,7 +15301,7 @@ Real64 GetCoilCapacity(EnergyPlusData &state,
 
 Real64 GetCoilCapacityByIndexType(EnergyPlusData &state,
                                   int const CoilIndex,    // must match coil index for the coil type
-                                  int const CoilType_Num, // must match coil types in this module
+                                  HVAC::CoilType const coilType, // must match coil types in this module
                                   bool &ErrorsFound       // set to true if problem
 )
 {
@@ -15212,15 +15332,15 @@ Real64 GetCoilCapacityByIndexType(EnergyPlusData &state,
         return CoilCapacity;
     }
 
-    if (CoilType_Num != state.dataDXCoils->DXCoil(CoilIndex).DXCoilType_Num) {
+    if (coilType != state.dataDXCoils->DXCoil(CoilIndex).coilType) {
         ShowSevereError(state, "GetCoilCapacityByIndexType: Index passed does not match DX Coil type passed.");
         ShowContinueError(state, "... returning capacity as -1000.");
         ErrorsFound = true;
         CoilCapacity = -1000.0;
     } else {
-        switch (state.dataDXCoils->DXCoil(CoilIndex).DXCoilType_Num) {
-        case HVAC::CoilDX_MultiSpeedCooling:
-        case HVAC::CoilDX_MultiSpeedHeating: {
+        switch (state.dataDXCoils->DXCoil(CoilIndex).coilType) {
+        case HVAC::CoilType::CoolingDXMultiSpeed:
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
             CoilCapacity = state.dataDXCoils->DXCoil(CoilIndex).MSRatedTotCap(state.dataDXCoils->DXCoil(CoilIndex).NumOfSpeeds);
         } break;
         default: {
@@ -15270,7 +15390,7 @@ int GetCoilTypeNum(EnergyPlusData &state,
 
     WhichCoil = Util::FindItemInList(CoilName, state.dataDXCoils->DXCoil);
     if (WhichCoil != 0) {
-        TypeNum = state.dataDXCoils->DXCoil(WhichCoil).DXCoilType_Num;
+        TypeNum = state.dataDXCoils->DXCoil(WhichCoil).coilType;
     } else {
         if (PrintMessage) {
             ShowSevereError(state, format("GetCoilTypeNum: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
@@ -15282,7 +15402,7 @@ int GetCoilTypeNum(EnergyPlusData &state,
     return TypeNum;
 }
 
-Real64 GetMinOATCompressor(EnergyPlusData &state,
+Real64 GetCoilMinOATCompressor(EnergyPlusData &state,
                            int const CoilIndex, // index to cooling coil
                            bool &ErrorsFound    // set to true if problem
 )
@@ -15304,6 +15424,7 @@ Real64 GetMinOATCompressor(EnergyPlusData &state,
     }
 }
 
+
 int GetCoilInletNode(EnergyPlusData &state,
                      std::string const &CoilType, // must match coil types in this module
                      std::string const &CoilName, // must match coil names for the coil type
@@ -15514,12 +15635,13 @@ Real64 GetDXCoilBypassedFlowFrac(EnergyPlusData &state,
 
     return BypassFraction;
 }
+#endif // OLD_API
 
 int GetHPCoolingCoilIndex(EnergyPlusData &state,
-                          std::string const &HeatingCoilType, // Type of DX heating coil used in HP
+                          HVAC::CoilType heatingCoilType, // Type of DX heating coil used in HP
                           std::string const &HeatingCoilName, // Name of DX heating coil used in HP
                           int const HeatingCoilIndex          // Index of DX heating coil used in HP
-)
+                          )
 {
 
     // FUNCTION INFORMATION:
@@ -15540,7 +15662,7 @@ int GetHPCoolingCoilIndex(EnergyPlusData &state,
     DXCoolingCoilIndex = 0;
 
     DataLoopNode::ConnectionObjectType HeatingCoilTypeNum = static_cast<DataLoopNode::ConnectionObjectType>(
-        getEnumValue(BranchNodeConnections::ConnectionObjectTypeNamesUC, Util::makeUPPER(HeatingCoilType)));
+        getEnumValue(BranchNodeConnections::ConnectionObjectTypeNamesUC, HVAC::coilTypeNamesUC[(int)heatingCoilType]));
 
     DataLoopNode::ConnectionObjectType CompSetsParentType; // Parent object type which uses DX heating coil pass into this function
     std::string CompSetsParentName;
@@ -15631,6 +15753,107 @@ int GetHPCoolingCoilIndex(EnergyPlusData &state,
     return DXCoolingCoilIndex;
 }
 
+int GetHPCoolingCoilIndex(EnergyPlusData &state, int const coilNum)
+{
+
+    // FUNCTION INFORMATION:
+    //       AUTHOR         R. Raustad
+    //       DATE WRITTEN   February 2007
+
+    // PURPOSE OF THIS FUNCTION:
+    // This function looks up the given DX heating coil and returns the companion DX cooling coil.
+
+    // Return value
+    int DXCoolingCoilIndex = 0; // Index of HP DX cooling coil returned from this function
+
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+    
+    DataLoopNode::ConnectionObjectType coilNodeType = static_cast<DataLoopNode::ConnectionObjectType>(
+        getEnumValue(BranchNodeConnections::ConnectionObjectTypeNamesUC, HVAC::coilTypeNamesUC[(int)dxCoil.coilType]));
+
+    DataLoopNode::ConnectionObjectType HXCompSetsParentType;
+    DataLoopNode::ConnectionObjectType CompSetsParentType;
+    std::string CompSetsParentName;
+    
+    for (auto const &compSet : state.dataBranchNodeConnections->CompSets) {
+
+        if (coilNodeType != compSet.ComponentObjectType ||
+            !Util::SameString(dxCoil.Name, compSet.CName))
+            continue;
+        
+        // Parent object type which uses DX heating coil pass into this function
+        CompSetsParentType = compSet.ParentObjectType;
+        CompSetsParentName = compSet.ParentCName;
+        
+        if ((CompSetsParentType == DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatPumpAirToAir) ||
+            (CompSetsParentType == DataLoopNode::ConnectionObjectType::ZoneHVACPackagedTerminalHeatPump) ||
+            (CompSetsParentType == DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed) ||
+            (CompSetsParentType == DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass) ||
+            (CompSetsParentType == DataLoopNode::ConnectionObjectType::AirLoopHVACUnitarySystem)) {
+            //       Search for DX cooling coils
+            for (auto const &compSet2 : state.dataBranchNodeConnections->CompSets) {
+                if (!Util::SameString(compSet2.ParentCName, CompSetsParentName)) continue;
+
+                if (compSet2.ComponentObjectType != DataLoopNode::ConnectionObjectType::CoilCoolingDXSingleSpeed &&
+                    compSet2.ComponentObjectType != DataLoopNode::ConnectionObjectType::CoilCoolingDXMultiSpeed) continue;
+
+                DXCoolingCoilIndex = Util::FindItemInList(compSet2.CName, state.dataDXCoils->DXCoil);
+                break;
+            }
+
+            // Search for Heat Exchanger Assisted DX cooling coils
+            if (DXCoolingCoilIndex == 0) {
+                for (auto const &compSet2 : state.dataBranchNodeConnections->CompSets) {
+                    if (!Util::SameString(compSet2.ParentCName, CompSetsParentName)) continue;
+                    
+                    if (compSet2.ComponentObjectType != DataLoopNode::ConnectionObjectType::CoilSystemCoolingDXHeatExchangerAssisted) continue;
+                    
+                    std::string const &HXCompSetsParentName = compSet2.CName;
+                    DataLoopNode::ConnectionObjectType HXCompSetsParentType = compSet2.ComponentObjectType;
+                    
+                    for (auto const &compSet3 : state.dataBranchNodeConnections->CompSets) { 
+                        if (!Util::SameString(compSet3.ParentCName, HXCompSetsParentName)) continue;
+                        if (compSet3.ComponentObjectType != DataLoopNode::ConnectionObjectType::CoilCoolingDXSingleSpeed) continue;
+                        DXCoolingCoilIndex = Util::FindItemInList(compSet3.CName, state.dataDXCoils->DXCoil);
+                        break;
+                    }
+                    break;
+                }
+            }
+        } else {
+            //     ErrorFound, Coil:Heating:DX:SingleSpeed is used in wrong type of parent object (should never get here)
+            ShowSevereError(state,
+                            format("Configuration error in {}\"{}\"",
+                                   BranchNodeConnections::ConnectionObjectTypeNames[static_cast<int>(CompSetsParentType)],
+                                   CompSetsParentName));
+            ShowContinueError(state, "DX heating coil not allowed in this configuration.");
+            ShowFatalError(state, "Preceding condition(s) causes termination.");
+        }
+        break;
+    }
+
+    // Check and warn user is crankcase heater power or max OAT for crankcase heater differs in DX cooling and heating coils
+    if (DXCoolingCoilIndex > 0) {
+        auto const &dxCoilCool = state.dataDXCoils->DXCoil(DXCoolingCoilIndex);
+        if (dxCoilCool.CrankcaseHeaterCapacity != 0.0) {
+            if (dxCoilCool.CrankcaseHeaterCapacity != dxCoil.CrankcaseHeaterCapacity ||
+                dxCoilCool.MaxOATCrankcaseHeater != dxCoil.MaxOATCrankcaseHeater) {
+                ShowWarningError(state, "Crankcase heater capacity or max outdoor temp for crankcase heater operation specified in");
+                ShowContinueError(state, format("Coil:Cooling:DX:SingleSpeed = {}", dxCoilCool.Name));
+                ShowContinueError(state, format("is different than that specified in Coil:Heating:DX:SingleSpeed = {}.", dxCoil.Name));
+                ShowContinueError(state,
+                                  format("Both of these DX coils are part of {}={}.",
+                                         BranchNodeConnections::ConnectionObjectTypeNames[static_cast<int>(CompSetsParentType)],
+                                         CompSetsParentName));
+                ShowContinueError(state, "The value specified in the DX heating coil will be used and the simulation continues...");
+            }
+        }
+    }
+
+    return DXCoolingCoilIndex;
+}
+      
 int GetDXCoilNumberOfSpeeds(EnergyPlusData &state,
                             std::string const &CoilType, // must match coil types in this module
                             std::string const &CoilName, // must match coil names for the coil type
@@ -15723,7 +15946,7 @@ Sched::Schedule *GetDXCoilAvailSched(EnergyPlusData &state,
 }
 
 Real64 GetDXCoilAirFlow(EnergyPlusData &state,
-                        std::string const &CoilType, // must match coil types in this module
+                        HVAC::CoilType coilType, // must match coil types in this module
                         std::string const &CoilName, // must match coil names for the coil type
                         bool &ErrorsFound            // set to true if problem
 )
@@ -15751,31 +15974,43 @@ Real64 GetDXCoilAirFlow(EnergyPlusData &state,
     }
 
     WhichCoil = Util::FindItemInList(CoilName, state.dataDXCoils->DXCoil);
-    if (WhichCoil != 0) {
-        switch (state.dataDXCoils->DXCoil(WhichCoil).DXCoilType_Num) {
-        case HVAC::CoilDX_CoolingSingleSpeed:
-        case HVAC::CoilDX_CoolingTwoSpeed:
-        case HVAC::CoilDX_HeatingEmpirical:
-        case HVAC::CoilDX_CoolingTwoStageWHumControl: {
-            AirFlow = state.dataDXCoils->DXCoil(WhichCoil).RatedAirVolFlowRate(1);
-        } break;
-        case HVAC::CoilDX_MultiSpeedCooling:
-        case HVAC::CoilDX_MultiSpeedHeating: {
-            AirFlow = state.dataDXCoils->DXCoil(WhichCoil).MSRatedAirVolFlowRate(1);
-        } break;
-        default: {
-            ShowSevereError(
-                state,
-                format("GetDXCoilAirFlow: Could not find Coil, Type=\"{}\" Name=\"{}\" when accessing coil air flow rate.", CoilType, CoilName));
-            ErrorsFound = true;
-            AirFlow = -1.0;
-        } break;
-        }
-    } else {
+
+    if (WhichCoil == 0) {
+        ShowSevereError(
+                        state, format("GetDXCoilAirFlow: Could not find Coil, Type=\"{}\" Name=\"{}\" when accessing coil air flow rate.", coilType, CoilName));
+        ErrorsFound = true;
+        return -1.0;
+    }
+
+    auto &dxCoil = state.dataDXCoils->DXCoil(WhichCoil);
+
+    if (dxCoil.coilType != coilType) {
+        ShowSevereError(
+                        state, format("GetDXCoilAirFlow: Coil \"{}\" has unexpected type.", CoilName, HVAC::coilTypeNames[(int)coilType]));
+        ErrorsFound = true;
+        return -1.0;
+    }
+
+    switch (dxCoil.coilType) {
+    case HVAC::CoilType::CoolingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoSpeed:
+    case HVAC::CoilType::HeatingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoStageWHumControl: {
+        AirFlow = dxCoil.RatedAirVolFlowRate(1);
+    } break;
+          
+    case HVAC::CoilType::CoolingDXMultiSpeed:
+    case HVAC::CoilType::HeatingDXMultiSpeed: {
+        AirFlow = dxCoil.MSRatedAirVolFlowRate(1);
+    } break;
+
+    default: {
         ShowSevereError(
-            state, format("GetDXCoilAirFlow: Could not find Coil, Type=\"{}\" Name=\"{}\" when accessing coil air flow rate.", CoilType, CoilName));
+                        state,
+                        format("GetDXCoilAirFlow: Could not find Coil, Type=\"{}\" Name=\"{}\" when accessing coil air flow rate.", HVAC::coilTypeNames[(int)coilType], CoilName));
         ErrorsFound = true;
         AirFlow = -1.0;
+    } break;
     }
 
     return AirFlow;
@@ -15805,34 +16040,36 @@ int GetDXCoilCapFTCurveIndex(EnergyPlusData &state,
         state.dataDXCoils->GetCoilsInputFlag = false;
     }
 
-    if (CoilIndex != 0) {
-        switch (state.dataDXCoils->DXCoil(CoilIndex).DXCoilType_Num) {
-        case HVAC::CoilDX_CoolingSingleSpeed:
-        case HVAC::CoilDX_CoolingTwoSpeed:
-        case HVAC::CoilDX_HeatingEmpirical:
-        case HVAC::CoilDX_CoolingTwoStageWHumControl: {
-            CapFTCurveIndex = state.dataDXCoils->DXCoil(CoilIndex).CCapFTemp(1);
-        } break;
-        case HVAC::CoilDX_MultiSpeedCooling:
-        case HVAC::CoilDX_MultiSpeedHeating: {
-            CapFTCurveIndex = state.dataDXCoils->DXCoil(CoilIndex).MSCCapFTemp(state.dataDXCoils->DXCoil(CoilIndex).NumOfSpeeds);
-        } break;
-        case HVAC::CoilVRF_Heating: {
-            CapFTCurveIndex = state.dataDXCoils->DXCoil(CoilIndex).CCapFTemp(1);
-        } break;
-        default: {
-            //        CALL ShowSevereError(state, 'GetDXCoilCapFTCurveIndex: Could not find Coil, Type="'// &
-            //             TRIM(cAllCoilTypes(DXCoil(CoilIndex)%DXCoilType_Num))//'" Name="'//TRIM(DXCoil(CoilIndex)%Name)//  &
-            //              '" when accessing coil capacity as a function of temperature curve.')
-            ErrorsFound = true;
-            CapFTCurveIndex = 0;
-        } break;
-        }
-    } else {
-        //    CALL ShowSevereError(state, 'GetDXCoilCapFTCurveIndex: Could not find Coil, Index = 0'// &
-        //          ' when accessing coil air flow rate.')
+    if (CoilIndex == 0) {
         ErrorsFound = true;
-        CapFTCurveIndex = 0;
+        return 0;
+    }
+
+    auto &dxCoil = state.dataDXCoils->DXCoil(CoilIndex);
+    switch (dxCoil.coilType) {
+    case HVAC::CoilType::CoolingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoSpeed:
+    case HVAC::CoilType::HeatingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoStageWHumControl: {
+        CapFTCurveIndex = dxCoil.CCapFTemp(1);
+    } break;
+
+    case HVAC::CoilType::CoolingDXMultiSpeed:
+    case HVAC::CoilType::HeatingDXMultiSpeed: {
+        CapFTCurveIndex = dxCoil.MSCCapFTemp(dxCoil.NumOfSpeeds);
+    } break;
+
+    case HVAC::CoilType::HeatingVRF: {
+      CapFTCurveIndex = dxCoil.CCapFTemp(1);
+    } break;
+
+    default: {
+      //        CALL ShowSevereError(state, 'GetDXCoilCapFTCurveIndex: Could not find Coil, Type="'// &
+      //             TRIM(cAllCoilTypes(DXCoil(CoilIndex)%coilType))//'" Name="'//TRIM(DXCoil(CoilIndex)%Name)//  &
+      //              '" when accessing coil capacity as a function of temperature curve.')
+      ErrorsFound = true;
+      CapFTCurveIndex = 0;
+    } break;
     }
 
     return CapFTCurveIndex;
@@ -15980,9 +16217,9 @@ void SetDXCoolingCoilData(
     if (present(supplyFanType)) {
         thisDXCoil.supplyFanType = supplyFanType;
         if (thisDXCoil.SupplyFanIndex > 0) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(state,
+            ReportCoilSelection::setCoilSupplyFanInfo(state,
                                                                                      thisDXCoil.Name,
-                                                                                     thisDXCoil.DXCoilType,
+                                                                                     thisDXCoil.coilType,
                                                                                      state.dataFans->fans(thisDXCoil.SupplyFanIndex)->Name,
                                                                                      state.dataFans->fans(thisDXCoil.SupplyFanIndex)->type,
                                                                                      thisDXCoil.SupplyFanIndex);
@@ -16201,10 +16438,10 @@ void CalcSecondaryDXCoils(EnergyPlusData &state, int const DXCoilNum)
     if (thisDXCoil.IsSecondaryDXCoilInZone) {
         auto &secZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(thisDXCoil.SecZonePtr);
         // Select the correct unit type
-        switch (thisDXCoil.DXCoilType_Num) {
-        case HVAC::CoilDX_CoolingSingleSpeed:
-        case HVAC::CoilDX_CoolingTwoSpeed:
-        case HVAC::CoilDX_MultiSpeedCooling: {
+        switch (thisDXCoil.coilType) {
+        case HVAC::CoilType::CoolingDXSingleSpeed:
+        case HVAC::CoilType::CoolingDXTwoSpeed:
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             // total sensible heat gain of the secondary zone from the secondary coil (condenser)
             if (thisDXCoil.ElecCoolingPower > 0.0) {
                 TotalHeatRejectionRate = thisDXCoil.TotalCoolingEnergyRate + thisDXCoil.ElecCoolingPower;
@@ -16214,7 +16451,7 @@ void CalcSecondaryDXCoils(EnergyPlusData &state, int const DXCoilNum)
             }
             thisDXCoil.SecCoilSensibleHeatGainRate = TotalHeatRejectionRate;
         } break;
-        case HVAC::CoilDX_HeatingEmpirical: {
+        case HVAC::CoilType::HeatingDXSingleSpeed: {
             // evaporator coil in the secondary zone
             if (thisDXCoil.ElecHeatingPower > 0.0) {
                 TotalHeatRemovalRate = max(0.0, thisDXCoil.TotalHeatingEnergyRate - thisDXCoil.ElecHeatingPower);
@@ -16280,7 +16517,8 @@ void CalcSecondaryDXCoils(EnergyPlusData &state, int const DXCoilNum)
             }
             thisDXCoil.SecCoilSHR = SHR;
         } break;
-        case HVAC::CoilDX_MultiSpeedHeating: {
+          
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
             EvapInletDryBulb = secZoneHB.ZT;
             EvapInletHumRat = secZoneHB.airHumRat;
             RhoAir = PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, EvapInletDryBulb, EvapInletHumRat);
@@ -16729,9 +16967,9 @@ void CalcVRFCoolingCoil_FluidTCtrl(EnergyPlusData &state,
                                   "   3) is used as part of a HX assisted cooling coil which uses a high sensible effectiveness. Check inputs.");
             }
             ShowRecurringWarningErrorAtEnd(state,
-                                           thisDXCoil.DXCoilType + " \"" + thisDXCoil.Name +
-                                               "\" - Full load outlet temperature indicates a possibility of frost/freeze error continues. "
-                                               "Outlet air temperature statistics follow:",
+                                           format("{}=\"{}\" - Full load outlet temperature indicates a possibility of frost/freeze error continues. "
+                                                  "Outlet air temperature statistics follow:",
+                                                  HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name),
                                            thisDXCoil.LowOutletTempIndex,
                                            thisDXCoil.FullLoadOutAirTempLast,
                                            thisDXCoil.FullLoadOutAirTempLast);
@@ -16748,7 +16986,8 @@ void CalcVRFCoolingCoil_FluidTCtrl(EnergyPlusData &state,
         (compressorOp == HVAC::CompressorOp::On)) { // for cycling fan, reset mass flow to full on rate
 
         if (thisDXCoil.RatedTotCap(Mode) <= 0.0) {
-            ShowFatalError(state, format("{} \"{}\" - Rated total cooling capacity is zero or less.", thisDXCoil.DXCoilType, thisDXCoil.Name));
+            ShowFatalError(state, format("{} \"{}\" - Rated total cooling capacity is zero or less.",
+                                         HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
         }
 
         TotCap = min(MaxCoolCap, thisDXCoil.RatedTotCap(Mode));
@@ -16913,7 +17152,7 @@ void CalcVRFCoolingCoil_FluidTCtrl(EnergyPlusData &state,
                 thisDXCoil.FullLoadInletAirTempLast = InletAirDryBulbTemp;
                 thisDXCoil.LowOutTempBuffer1 = format("{} \"{}\" - Full load outlet air dry-bulb temperature < 2C. This indicates the "
                                                       "possibility of coil frost/freeze. Outlet temperature = {:.2R} C.",
-                                                      thisDXCoil.DXCoilType,
+                                                      HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                       thisDXCoil.Name,
                                                       OutletAirTemp);
                 thisDXCoil.LowOutTempBuffer2 = " ...Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + " " +
@@ -17162,7 +17401,8 @@ void CalcVRFHeatingCoil_FluidTCtrl(EnergyPlusData &state,
         // Model was extended to accept bi-quadratic curves. This allows sensitivity of the EIR
         // to the entering dry-bulb temperature as well as the outside dry-bulb temperature. User is
         // advised to use the bi-quaratic curve if sufficient manufacturer data is available.
-        if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating && thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_FluidTCtrl_Heating) {
+        if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRF &&
+            thisDXCoil.coilType != HVAC::CoilType::HeatingVRFFluidTCtrl) {
             if (state.dataCurveManager->curves(thisDXCoil.EIRFTemp(Mode))->numDims == 1) {
                 EIRTempModFac = CurveValue(state, thisDXCoil.EIRFTemp(Mode), OutdoorDryBulb);
             } else {
@@ -17182,7 +17422,8 @@ void CalcVRFHeatingCoil_FluidTCtrl(EnergyPlusData &state,
             PLRHeating = min(1.0, PartLoadRatio);
         }
 
-        if (thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_Heating && thisDXCoil.DXCoilType_Num != HVAC::CoilVRF_FluidTCtrl_Heating) {
+        if (thisDXCoil.coilType != HVAC::CoilType::HeatingVRF &&
+            thisDXCoil.coilType != HVAC::CoilType::HeatingVRFFluidTCtrl) {
             PLF = CurveValue(state, thisDXCoil.PLFFPLR(Mode), PLRHeating); // Calculate part-load factor
         } else {
             PLF = 1.0;
@@ -17826,4 +18067,248 @@ void DisableLatentDegradation(EnergyPlusData &state, int const DXCoilNum)
     state.dataDXCoils->DXCoil(DXCoilNum).Twet_Rated(1) = 0.0;
 }
 
+Real64 GetCoilBypassedFlowFrac(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    return state.dataDXCoils->DXCoil(coilNum).BypassedFlowFrac(1);
+}
+
+
+Real64 GetCoilAirFlow(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+
+    switch (dxCoil.coilType) {
+    case HVAC::CoilType::CoolingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoSpeed:
+    case HVAC::CoilType::HeatingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoStageWHumControl: {
+        return dxCoil.RatedAirVolFlowRate(1);
+    } break;
+          
+    case HVAC::CoilType::CoolingDXMultiSpeed:
+    case HVAC::CoilType::HeatingDXMultiSpeed: {
+        return dxCoil.MSRatedAirVolFlowRate(1);
+    } break;
+
+    default: {
+      assert(false);
+      return -1.0;
+    } break;
+    }
+}
+  
+Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+    switch (dxCoil.coilType) {
+    case HVAC::CoilType::CoolingDXSingleSpeed:
+    case HVAC::CoilType::HeatingDXSingleSpeed: 
+    case HVAC::CoilType::CoolingDXTwoSpeed: {
+        return dxCoil.RatedTotCap(1);
+    } break;
+      
+    case HVAC::CoilType::CoolingDXTwoStageWHumControl: {
+        return dxCoil.RatedTotCap(dxCoil.NumCapacityStages);
+    } break;
+          
+    case HVAC::CoilType::CoolingDXMultiSpeed:
+    case HVAC::CoilType::HeatingDXMultiSpeed: {
+        return dxCoil.MSRatedTotCap(dxCoil.NumOfSpeeds);
+    } break;
+
+    default: {
+        return dxCoil.RatedTotCap(dxCoil.NumCapacityStages);
+
+        // This is the difference between GetCoilCapacity and GetCoilCapacityByIndexType() -- Why?
+        
+        // ShowSevereError(state, format("GetCoilCapacity: Could not find Coil, Type=\"{}\" Name=\"{}\"",
+        //                              HVAC::coilTypeNames[(int)dxCoil.coilType], dxCoil.Name));
+        // ShowContinueError(state, "... returning capacity as -1000.");
+        // return -1000.0;
+        
+    } break;
+    }
+}
+
+Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    return state.dataDXCoils->DXCoil(coilNum).availSched;
+}
+
+int GetCoilCapFTCurve(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+    switch (dxCoil.coilType) {
+    case HVAC::CoilType::CoolingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoSpeed:
+    case HVAC::CoilType::HeatingDXSingleSpeed:
+    case HVAC::CoilType::CoolingDXTwoStageWHumControl: {
+        return dxCoil.CCapFTemp(1);
+    } break;
+
+    case HVAC::CoilType::CoolingDXMultiSpeed:
+    case HVAC::CoilType::HeatingDXMultiSpeed: {
+        return dxCoil.MSCCapFTemp(dxCoil.NumOfSpeeds);
+    } break;
+
+    case HVAC::CoilType::HeatingVRF: {
+        return dxCoil.CCapFTemp(1);
+    } break;
+
+    default: {
+        assert(false);
+        return 0;
+    } break;
+    }
+}
+
+int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    return state.dataDXCoils->DXCoil(coilNum).AirInNode;
+}
+
+int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    return state.dataDXCoils->DXCoil(coilNum).AirOutNode;
+}
+
+Real64 GetCoilMinOATCompressor(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    return state.dataDXCoils->DXCoil(coilNum).MinOATCompressor;
+}
+
+int GetCoilNumberOfSpeeds(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    return state.dataDXCoils->DXCoil(coilNum).NumOfSpeeds;
+}
+
+int GetCoilCondenserInletNode(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    return state.dataDXCoils->DXCoil(coilNum).CondenserInletNodeNum(1);
+}
+
+void SetCoilHeatingPLFCurve(EnergyPlusData &state, int const coilNum, int heatingPLFCurve)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).HeatingCoilPLFCurvePTR = heatingPLFCurve;
+}
+
+void SetCoilDefrostEIR(EnergyPlusData &state, int const coilNum, int defrostEIR)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).DefrostEIRFT = defrostEIR;
+}
+
+void SetCoilCondenserType(EnergyPlusData &state, int const coilNum, DataHeatBalance::RefrigCondenserType condenserType)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).CondenserType = condenserType;
+}
+  
+void SetCoilHeatSizeRatio(EnergyPlusData &state, int const coilNum, Real64 heatSizeRatio)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).HeatSizeRatio = heatSizeRatio;
+}
+
+void SetCoilMaxOATCrankcaseHeater(EnergyPlusData &state, int const coilNum, Real64 maxOATCrankcaseHeater)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).MaxOATCrankcaseHeater = maxOATCrankcaseHeater;
+}
+
+void SetCoilSystemHeatingDXFlag(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).FindCompanionUpStreamCoil = false;
+}
+
+void SetCoilCoolingCoilPresent(EnergyPlusData &state, int const coilNum, bool coolingCoilPresent)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).CoolingCoilPresent = coolingCoilPresent;
+}
+
+void SetCoilHeatingCoilPresent(EnergyPlusData &state, int const coilNum, bool heatingCoilPresent)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).HeatingCoilPresent = heatingCoilPresent;
+}
+
+void SetCoilCondenserInletNode(EnergyPlusData &state, int const coilNum, int condenserInletNode)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).CondenserInletNodeNum(1) = condenserInletNode;
+}
+
+void SetCoilOATCoolingInfo(EnergyPlusData &state, int const coilNum, Real64 minOATCooling, Real64 maxOATCooling)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+    dxCoil.MinOATCompressor = minOATCooling;
+    dxCoil.MaxOATCompressor = maxOATCooling;
+}
+
+void SetCoilOATHeatingInfo(EnergyPlusData &state, int const coilNum, Real64 minOAT, Real64 maxOAT, HVAC::OATType oatType)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+    dxCoil.MinOATCompressor = minOAT;
+    dxCoil.MaxOATCompressor = maxOAT;
+    dxCoil.HeatingPerformanceOATType = oatType;
+}
+
+void SetCoilSupplyFanInfo(EnergyPlusData &state, int const coilNum, int fanIndex, std::string const &fanName, HVAC::FanType fanType) 
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+    dxCoil.SupplyFanIndex = fanIndex;
+    dxCoil.SupplyFanName = fanName;
+    dxCoil.supplyFanType = fanType;
+    if (dxCoil.SupplyFanIndex > 0) {
+        ReportCoilSelection::setCoilSupplyFanInfo(state,
+                                                  dxCoil.Name,
+                                                  dxCoil.coilType,
+                                                  dxCoil.SupplyFanName,
+                                                  dxCoil.supplyFanType,
+                                                  dxCoil.SupplyFanIndex);
+    }
+}
+
+void SetCoilTotalCapacity(EnergyPlusData &state, int const coilNum, Real64 totCap)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    state.dataDXCoils->DXCoil(coilNum).RatedTotCap(1) = totCap;
+}
+
+void SetCoilDefrostInfo(EnergyPlusData &state,
+                        int const coilNum,
+                        StandardRatings::DefrostStrat defrostStrategy,
+                        StandardRatings::HPdefrostControl defrostControl,
+                        int defrostEIR,
+                        Real64 defrostFraction,
+                        Real64 maxOATDefrost, 
+                        Real64 defrostCapacity)
+{
+    assert(coilNum > 0 && coilNum <= state.dataDXCoils->NumDXCoils);
+    auto &dxCoil = state.dataDXCoils->DXCoil(coilNum);
+    dxCoil.DefrostStrategy = defrostStrategy;
+    dxCoil.DefrostControl = defrostControl;
+    dxCoil.DefrostEIRFT = defrostEIR;
+    dxCoil.DefrostTime = defrostFraction;
+    dxCoil.MaxOATDefrost = maxOATDefrost;
+    dxCoil.DefrostCapacity = defrostCapacity;
+}  
+
+
 } // namespace EnergyPlus::DXCoils
diff --git a/src/EnergyPlus/DXCoils.hh b/src/EnergyPlus/DXCoils.hh
index 41fddb8eb85..921512fa977 100644
--- a/src/EnergyPlus/DXCoils.hh
+++ b/src/EnergyPlus/DXCoils.hh
@@ -110,9 +110,9 @@ namespace DXCoils {
         // Members
         //          Some variables in this type are arrays (dimension=MaxModes) to support coil type
         //          COIL:DX:MultiMode:CoolingEmpirical.  Other coil types only use the first element.
+
         std::string Name;                      // Name of the DX Coil
-        std::string DXCoilType;                // type of coil
-        int DXCoilType_Num;                    // Integer equivalent to DXCoilType
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;     // Integer equivalent to DXCoilType
         Sched::Schedule *availSched = nullptr; // availability schedule
         //          RatedCoolCap, RatedSHR and RatedCOP do not include the thermal or electrical
         //          effects due to the supply air fan
@@ -285,9 +285,8 @@ namespace DXCoils {
         // always 1 for other coils
         int NumDehumidModes; // number of enhanced dehumidification modes, up to MaxDehumidModes for Multimode DX coil,
         // always 0 for other coils)
-        Array1D_string CoilPerformanceType;                            // Coil Performance object type
-        Array1D_int CoilPerformanceType_Num;                           // Coil Performance object type number
-        Array1D_string CoilPerformanceName;                            // Coil Performance object names
+        Array1D<HVAC::CoilType> coilPerformanceTypes;                           // Coil Performance object type number
+        Array1D_string coilPerformanceNames;                            // Coil Performance object names
         Real64 CoolingCoilStg2RuntimeFrac;                             // Run time fraction of stage 2
         HVAC::CoilMode DehumidificationMode = HVAC::CoilMode::Invalid; // Dehumidification mode for multimode coil,
         // 0=normal, 1+=enhanced dehumidification mode
@@ -459,7 +458,7 @@ namespace DXCoils {
 
         // Default Constructor
         DXCoilData()
-            : DXCoilType_Num(0), RatedTotCap(MaxModes, 0.0), HeatSizeRatio(1.0), RatedTotCapEMSOverrideOn(MaxModes, false),
+            : RatedTotCap(MaxModes, 0.0), HeatSizeRatio(1.0), RatedTotCapEMSOverrideOn(MaxModes, false),
               RatedTotCapEMSOverrideValue(MaxModes, 0.0), FrostHeatingCapacityMultiplierEMSOverrideOn(false),
               FrostHeatingCapacityMultiplierEMSOverrideValue(0.0), FrostHeatingInputPowerMultiplierEMSOverrideOn(false),
               FrostHeatingInputPowerMultiplierEMSOverrideValue(0.0), RatedSHR(MaxModes, 0.0), RatedSHREMSOverrideOn(MaxModes, false),
@@ -472,44 +471,44 @@ namespace DXCoils {
               CrankcaseHeaterPower(0.0), MaxOATCrankcaseHeater(0.0), CrankcaseHeaterCapacityCurveIndex(0), CrankcaseHeaterConsumption(0.0),
               BasinHeaterPowerFTempDiff(0.0), BasinHeaterSetPointTemp(0.0), CompanionUpstreamDXCoil(0), FindCompanionUpStreamCoil(true),
               CondenserInletNodeNum(MaxModes, 0), LowOutletTempIndex(0), FullLoadOutAirTempLast(0.0), FullLoadInletAirTempLast(0.0),
-              PrintLowOutTempMessage(false), HeatingCoilPLFCurvePTR(0), RatedTotCap2(0.0), RatedSHR2(0.0), RatedCOP2(0.0), RatedAirVolFlowRate2(0.0),
-              FanPowerPerEvapAirFlowRate_LowSpeed(MaxModes, 0.0), FanPowerPerEvapAirFlowRate_2023_LowSpeed(MaxModes, 0.0), RatedAirMassFlowRate2(0.0),
-              RatedCBF2(0.0), CCapFTemp2(0), EIRFTemp2(0), RatedEIR2(0.0), InternalStaticPressureDrop(0.0), RateWithInternalStaticAndFanObject(false),
-              SupplyFanIndex(0), supplyFanType(HVAC::FanType::Invalid), RatedEIR(MaxModes, 0.0), InletAirMassFlowRate(0.0),
-              InletAirMassFlowRateMax(0.0), InletAirTemp(0.0), InletAirHumRat(0.0), InletAirEnthalpy(0.0), OutletAirTemp(0.0), OutletAirHumRat(0.0),
-              OutletAirEnthalpy(0.0), PartLoadRatio(0.0), TotalCoolingEnergy(0.0), SensCoolingEnergy(0.0), LatCoolingEnergy(0.0),
-              TotalCoolingEnergyRate(0.0), SensCoolingEnergyRate(0.0), LatCoolingEnergyRate(0.0), ElecCoolingConsumption(0.0), ElecCoolingPower(0.0),
-              CoolingCoilRuntimeFraction(0.0), TotalHeatingEnergy(0.0), TotalHeatingEnergyRate(0.0), ElecHeatingConsumption(0.0),
-              ElecHeatingPower(0.0), HeatingCoilRuntimeFraction(0.0), DefrostStrategy(StandardRatings::DefrostStrat::Invalid),
-              DefrostControl(StandardRatings::HPdefrostControl::Invalid), EIRFPLR(0), DefrostEIRFT(0), RegionNum(0), MinOATCompressor(0.0),
-              OATempCompressorOn(0.0), MaxOATCompressor(0.0), MaxOATDefrost(0.0), DefrostTime(0.0), DefrostCapacity(0.0), HPCompressorRuntime(0.0),
-              HPCompressorRuntimeLast(0.0), TimeLeftToDefrost(0.0), DefrostPower(0.0), DefrostConsumption(0.0),
-              HeatingPerformanceOATType(HVAC::OATType::DryBulb), HPCoilIsInCoilSystemHeatingDX(false), OATempCompressorOnOffBlank(false),
-              Twet_Rated(MaxModes, 0.0), Gamma_Rated(MaxModes, 0.0), MaxONOFFCyclesperHour(MaxModes, 0.0), LatentCapacityTimeConstant(MaxModes, 0.0),
-              CondenserType(MaxModes, DataHeatBalance::RefrigCondenserType::Air), ReportEvapCondVars(false), EvapCondEffect(MaxModes, 0.0),
-              CondInletTemp(0.0), EvapCondAirFlow(MaxModes, 0.0), EvapCondPumpElecNomPower(MaxModes, 0.0), EvapCondPumpElecPower(0.0),
-              EvapCondPumpElecConsumption(0.0), EvapWaterConsumpRate(0.0), EvapWaterConsump(0.0), EvapCondAirFlow2(0.0), EvapCondEffect2(0.0),
-              EvapCondPumpElecNomPower2(0.0), BasinHeaterPower(0.0), BasinHeaterConsumption(0.0), NumCapacityStages(1), NumDehumidModes(0),
-              CoilPerformanceType(MaxModes), CoilPerformanceType_Num(MaxModes, 0), CoilPerformanceName(MaxModes), CoolingCoilStg2RuntimeFrac(0.0),
-              WaterInNode(0), WaterOutNode(0), HCOPFTemp(0), HCOPFTempErrorIndex(0), HCOPFAirFlow(0), HCOPFAirFlowErrorIndex(0), HCOPFWaterFlow(0),
-              HCOPFWaterFlowErrorIndex(0), HCapFTemp(0), HCapFTempErrorIndex(0), HCapFAirFlow(0), HCapFAirFlowErrorIndex(0), HCapFWaterFlow(0),
-              HCapFWaterFlowErrorIndex(0), RatedInletDBTemp(0.0), RatedInletWBTemp(0.0), RatedInletWaterTemp(0.0), HPWHCondPumpElecNomPower(0.0),
-              HPWHCondPumpFracToWater(0.0), RatedHPWHCondWaterFlow(0.0), ElecWaterHeatingPower(0.0), ElecWaterHeatingConsumption(0.0),
-              FanPowerIncludedInCOP(true), CondPumpHeatInCapacity(false), CondPumpPowerInCOP(false), LowTempLast(0.0), HighTempLast(0.0),
-              ErrIndex1(0), ErrIndex2(0), ErrIndex3(0), ErrIndex4(0), LowAmbErrIndex(0), HighAmbErrIndex(0), PLFErrIndex(0), PLRErrIndex(0),
-              PrintLowAmbMessage(false), PrintHighAmbMessage(false), EvapWaterSupplyMode(EvapWaterSupply::FromMains), EvapWaterSupTankID(0),
-              EvapWaterTankDemandARRID(0), CondensateCollectMode(CondensateCollectAction::Discard), CondensateTankID(0), CondensateTankSupplyARRID(0),
-              CondensateVdot(0.0), CondensateVol(0.0), CurrentEndTimeLast(0.0), TimeStepSysLast(0.0), FuelType(Constant::eFuel::Invalid),
-              NumOfSpeeds(0), PLRImpact(false), LatentImpact(false), MSFuelWasteHeat(0.0), MSHPHeatRecActive(false), MSHPDesignSpecIndex(0),
-              CoolingCoilPresent(true), HeatingCoilPresent(true), ISHundredPercentDOASDXCoil(false), SHRFTemp(MaxModes, 0), SHRFTempErrorIndex(0),
-              SHRFFlow(MaxModes, 0), SHRFFlowErrorIndex(0), SHRFTemp2(0), SHRFFlow2(0), UserSHRCurveExists(false), ASHRAE127StdRprt(false),
-              SecZonePtr(0), SecCoilSHRFT(0), SecCoilSHRFF(0), SecCoilAirFlow(0.0), SecCoilAirFlowScalingFactor(1.0), SecCoilRatedSHR(1.0),
-              SecCoilSHR(1.0), EvapInletWetBulb(0.0), SecCoilSensibleHeatGainRate(0.0), SecCoilTotalHeatRemovalRate(0.0),
-              SecCoilSensibleHeatRemovalRate(0.0), SecCoilLatentHeatRemovalRate(0.0), IsSecondaryDXCoilInZone(false), IsDXCoilInZone(false),
-              CompressorPartLoadRatio(0.0), MSSpeedNumLS(1), MSSpeedNumHS(2), MSSpeedRatio(0.0), MSCycRatio(0.0), VRFIUPtr(0), VRFOUPtr(0),
-              EvaporatingTemp(4.0), CondensingTemp(40.0), C1Te(0.0), C2Te(0.0), C3Te(0.0), C1Tc(0.0), C2Tc(0.0), C3Tc(0.0), SH(0.0), SC(0.0),
-              ActualSH(0.0), ActualSC(0.0), RateBFVRFIUEvap(0.0592), RateBFVRFIUCond(0.1360), CAPFTErrIndex(0), EIRFTErrIndex(0),
-              reportCoilFinalSizes(true), capModFacTotal(0.0), AirLoopNum(0)
+              PrintLowOutTempMessage(false), HeatingCoilPLFCurvePTR(0), RatedTotCap2(0.0), RatedSHR2(0.0), RatedCOP2(0.0),
+              RatedAirVolFlowRate2(0.0), FanPowerPerEvapAirFlowRate_LowSpeed(MaxModes, 0.0), FanPowerPerEvapAirFlowRate_2023_LowSpeed(MaxModes, 0.0),
+              RatedAirMassFlowRate2(0.0), RatedCBF2(0.0), CCapFTemp2(0), EIRFTemp2(0), RatedEIR2(0.0), InternalStaticPressureDrop(0.0),
+              RateWithInternalStaticAndFanObject(false), SupplyFanIndex(0), supplyFanType(HVAC::FanType::Invalid), RatedEIR(MaxModes, 0.0),
+              InletAirMassFlowRate(0.0), InletAirMassFlowRateMax(0.0), InletAirTemp(0.0), InletAirHumRat(0.0), InletAirEnthalpy(0.0),
+              OutletAirTemp(0.0), OutletAirHumRat(0.0), OutletAirEnthalpy(0.0), PartLoadRatio(0.0), TotalCoolingEnergy(0.0), SensCoolingEnergy(0.0),
+              LatCoolingEnergy(0.0), TotalCoolingEnergyRate(0.0), SensCoolingEnergyRate(0.0), LatCoolingEnergyRate(0.0), ElecCoolingConsumption(0.0),
+              ElecCoolingPower(0.0), CoolingCoilRuntimeFraction(0.0), TotalHeatingEnergy(0.0), TotalHeatingEnergyRate(0.0),
+              ElecHeatingConsumption(0.0), ElecHeatingPower(0.0), HeatingCoilRuntimeFraction(0.0),
+              DefrostStrategy(StandardRatings::DefrostStrat::Invalid), DefrostControl(StandardRatings::HPdefrostControl::Invalid), EIRFPLR(0),
+              DefrostEIRFT(0), RegionNum(0), MinOATCompressor(0.0), OATempCompressorOn(0.0), MaxOATCompressor(0.0), MaxOATDefrost(0.0),
+              DefrostTime(0.0), DefrostCapacity(0.0), HPCompressorRuntime(0.0), HPCompressorRuntimeLast(0.0), TimeLeftToDefrost(0.0),
+              DefrostPower(0.0), DefrostConsumption(0.0), HeatingPerformanceOATType(HVAC::OATType::DryBulb), HPCoilIsInCoilSystemHeatingDX(false),
+              OATempCompressorOnOffBlank(false), Twet_Rated(MaxModes, 0.0), Gamma_Rated(MaxModes, 0.0), MaxONOFFCyclesperHour(MaxModes, 0.0),
+              LatentCapacityTimeConstant(MaxModes, 0.0), CondenserType(MaxModes, DataHeatBalance::RefrigCondenserType::Air),
+              ReportEvapCondVars(false), EvapCondEffect(MaxModes, 0.0), CondInletTemp(0.0), EvapCondAirFlow(MaxModes, 0.0),
+              EvapCondPumpElecNomPower(MaxModes, 0.0), EvapCondPumpElecPower(0.0), EvapCondPumpElecConsumption(0.0), EvapWaterConsumpRate(0.0),
+              EvapWaterConsump(0.0), EvapCondAirFlow2(0.0), EvapCondEffect2(0.0), EvapCondPumpElecNomPower2(0.0), BasinHeaterPower(0.0),
+              BasinHeaterConsumption(0.0), NumCapacityStages(1), NumDehumidModes(0), coilPerformanceTypes(MaxModes, HVAC::CoilType::Invalid),
+              coilPerformanceNames(MaxModes), CoolingCoilStg2RuntimeFrac(0.0), WaterInNode(0), WaterOutNode(0),
+              HCOPFTemp(0), HCOPFTempErrorIndex(0), HCOPFAirFlow(0), HCOPFAirFlowErrorIndex(0), HCOPFWaterFlow(0), HCOPFWaterFlowErrorIndex(0),
+              HCapFTemp(0), HCapFTempErrorIndex(0), HCapFAirFlow(0), HCapFAirFlowErrorIndex(0), HCapFWaterFlow(0), HCapFWaterFlowErrorIndex(0),
+              RatedInletDBTemp(0.0), RatedInletWBTemp(0.0), RatedInletWaterTemp(0.0), HPWHCondPumpElecNomPower(0.0), HPWHCondPumpFracToWater(0.0),
+              RatedHPWHCondWaterFlow(0.0), ElecWaterHeatingPower(0.0), ElecWaterHeatingConsumption(0.0), FanPowerIncludedInCOP(true),
+              CondPumpHeatInCapacity(false), CondPumpPowerInCOP(false), LowTempLast(0.0), HighTempLast(0.0), ErrIndex1(0), ErrIndex2(0), ErrIndex3(0),
+              ErrIndex4(0), LowAmbErrIndex(0), HighAmbErrIndex(0), PLFErrIndex(0), PLRErrIndex(0), PrintLowAmbMessage(false),
+              PrintHighAmbMessage(false), EvapWaterSupplyMode(EvapWaterSupply::FromMains), EvapWaterSupTankID(0), EvapWaterTankDemandARRID(0),
+              CondensateCollectMode(CondensateCollectAction::Discard), CondensateTankID(0), CondensateTankSupplyARRID(0), CondensateVdot(0.0),
+              CondensateVol(0.0), CurrentEndTimeLast(0.0), TimeStepSysLast(0.0), FuelType(Constant::eFuel::Invalid), NumOfSpeeds(0), PLRImpact(false),
+              LatentImpact(false), MSFuelWasteHeat(0.0), MSHPHeatRecActive(false), MSHPDesignSpecIndex(0), CoolingCoilPresent(true),
+              HeatingCoilPresent(true), ISHundredPercentDOASDXCoil(false), SHRFTemp(MaxModes, 0), SHRFTempErrorIndex(0), SHRFFlow(MaxModes, 0),
+              SHRFFlowErrorIndex(0), SHRFTemp2(0), SHRFFlow2(0), UserSHRCurveExists(false), ASHRAE127StdRprt(false), SecZonePtr(0), SecCoilSHRFT(0),
+              SecCoilSHRFF(0), SecCoilAirFlow(0.0), SecCoilAirFlowScalingFactor(1.0), SecCoilRatedSHR(1.0), SecCoilSHR(1.0), EvapInletWetBulb(0.0),
+              SecCoilSensibleHeatGainRate(0.0), SecCoilTotalHeatRemovalRate(0.0), SecCoilSensibleHeatRemovalRate(0.0),
+              SecCoilLatentHeatRemovalRate(0.0), IsSecondaryDXCoilInZone(false), IsDXCoilInZone(false), CompressorPartLoadRatio(0.0), MSSpeedNumLS(1),
+              MSSpeedNumHS(2), MSSpeedRatio(0.0), MSCycRatio(0.0), VRFIUPtr(0), VRFOUPtr(0), EvaporatingTemp(4.0), CondensingTemp(40.0), C1Te(0.0),
+              C2Te(0.0), C3Te(0.0), C1Tc(0.0), C2Tc(0.0), C3Tc(0.0), SH(0.0), SC(0.0), ActualSH(0.0), ActualSC(0.0), RateBFVRFIUEvap(0.0592),
+              RateBFVRFIUCond(0.1360), CAPFTErrIndex(0), EIRFTErrIndex(0), reportCoilFinalSizes(true), capModFacTotal(0.0), AirLoopNum(0)
         {
         }
     };
@@ -551,6 +550,18 @@ namespace DXCoils {
                    ObjexxFCL::Optional<Real64 const> CompCyclingRatio = _            // cycling ratio of VRF condenser connected to this TU
     );
 
+    void SimDXCoil(EnergyPlusData &state,
+                   int const coilNum,
+                   HVAC::CompressorOp const compressorOp, // compressor operation; 1=on, 0=off
+                   bool const FirstHVACIteration,         // True when first HVAC iteration
+                   HVAC::FanOp const fanOp,                                          // allows parent object to control fan mode
+                   ObjexxFCL::Optional<Real64 const> PartLoadRatio = _,              // part load ratio (for single speed cycling unit)
+                   ObjexxFCL::Optional<Real64 const> OnOffAFR = _,                   // ratio of compressor on airflow to compressor off airflow
+                   ObjexxFCL::Optional<Real64 const> CoilCoolingHeatingPLRRatio = _, // used for cycling fan RH control
+                   ObjexxFCL::Optional<Real64 const> MaxCap = Constant::MaxCap,      // maximum cooling capacity of VRF terminal units
+                   ObjexxFCL::Optional<Real64 const> CompCyclingRatio = _            // cycling ratio of VRF condenser connected to this TU
+    );
+  
     void SimDXCoilMultiSpeed(EnergyPlusData &state,
                              std::string_view CompName, // name of the fan coil unit
                              Real64 const SpeedRatio,   // = (CompressorSpeed - CompressorSpeedMin) /
@@ -562,6 +573,16 @@ namespace DXCoils {
                              ObjexxFCL::Optional_int_const SingleMode = _               // Single mode operation Yes/No; 1=Yes, 0=No
     );
 
+    void SimDXCoilMultiSpeed(EnergyPlusData &state,
+                             int const coilNum,
+                             Real64 const SpeedRatio,   // = (CompressorSpeed - CompressorSpeedMin) /
+                             Real64 const CycRatio,     // cycling part load ratio for variable speed
+                             ObjexxFCL::Optional_int_const SpeedNum = _,                // Speed number for multispeed cooling coil onlyn
+                             ObjexxFCL::Optional<HVAC::FanOp const> fanOp = _,          // Fan operation mode
+                             HVAC::CompressorOp CompressorOp = HVAC::CompressorOp::Off, // Compressor on/off; 1=on, 0=off
+                             ObjexxFCL::Optional_int_const SingleMode = _               // Single mode operation Yes/No; 1=Yes, 0=No
+    );
+  
     void SimDXCoilMultiMode(EnergyPlusData &state,
                             std::string_view CompName,        // name of the fan coil unit
                             HVAC::CompressorOp compressorOp,  // compressor operation; 1=on, 0=off !unused1208
@@ -572,6 +593,15 @@ namespace DXCoils {
                             HVAC::FanOp const fanOp // allows parent object to control fan mode
     );
 
+    void SimDXCoilMultiMode(EnergyPlusData &state,
+                            int const coilNum,
+                            HVAC::CompressorOp compressorOp,  // compressor operation; 1=on, 0=off !unused1208
+                            bool const FirstHVACIteration,    // true if first hvac iteration
+                            Real64 const PartLoadRatio,       // part load ratio
+                            HVAC::CoilMode const DehumidMode, // dehumidification mode (0=normal, 1=enhanced)
+                            HVAC::FanOp const fanOp // allows parent object to control fan mode
+    );
+  
     // TODO: Add New Property for AHRI 2023 Standard & Modify Numeric Fields (increment)
     void GetDXCoils(EnergyPlusData &state);
 
@@ -632,7 +662,7 @@ namespace DXCoils {
     );
 
     Real64 CalcCBF(EnergyPlusData &state,
-                   std::string const &UnitType,
+                   HVAC::CoilType coilType, 
                    std::string const &UnitName,
                    Real64 const InletAirTemp,   // inlet air temperature [C]
                    Real64 const InletAirHumRat, // inlet air humidity ratio [kg water / kg dry air]
@@ -643,7 +673,7 @@ namespace DXCoils {
     );
 
     Real64 ValidateADP(EnergyPlusData &state,
-                       std::string const &UnitType,      // component name
+                       HVAC::CoilType coilType,      // component name
                        std::string const &UnitName,      // component type
                        Real64 const RatedInletAirTemp,   // coil inlet air temperature [C]
                        Real64 const RatedInletAirHumRat, // coil inlet air humidity ratio [kg/kg]
@@ -711,61 +741,13 @@ namespace DXCoils {
     void GetFanIndexForTwoSpeedCoil(
         EnergyPlusData &state, int const CoolingCoilIndex, int &SupplyFanIndex, std::string &SupplyFanName, HVAC::FanType &supplyFanType);
 
-    void GetDXCoilIndex(EnergyPlusData &state,
-                        std::string const &DXCoilName,
-                        int &DXCoilIndex,
-                        bool &ErrorsFound,
-                        std::string_view const ThisObjectType = {},
-                        bool const SuppressWarning = false);
+    void GetCoilIndex(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
+#ifdef OLD_API
+    Real64 GetCoilCapacity(EnergyPlusData &state, std::string_view const coilType, std::string const &CoilName, bool &ErrorsFound);
 
-    std::string GetDXCoilName(
-        EnergyPlusData &state, int &DXCoilIndex, bool &ErrorsFound, std::string_view const ThisObjectType = {}, bool const SuppressWarning = false);
-
-    Real64 GetCoilCapacity(EnergyPlusData &state,
-                           std::string const &CoilType, // must match coil types in this module
-                           std::string const &CoilName, // must match coil names for the coil type
-                           bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilAirOutletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    Real64 GetCoilCapacityByIndexType(EnergyPlusData &state,
-                                      int const CoilIndex,    // must match coil index for the coil type
-                                      int const CoilType_Num, // must match coil types in this module
-                                      bool &ErrorsFound       // set to true if problem
-    );
-
-    int GetCoilTypeNum(EnergyPlusData &state,
-                       std::string const &CoilType,                    // must match coil types in this module
-                       std::string const &CoilName,                    // must match coil names for the coil type
-                       bool &ErrorsFound,                              // set to true if problem
-                       ObjexxFCL::Optional_bool_const PrintWarning = _ // prints warning when true
-    );
-
-    Real64 GetMinOATCompressor(EnergyPlusData &state,
-                               int const CoilIndex, // index to coil
-                               bool &ErrorsFound    // set to true if problem
-    );
-
-    int GetCoilInletNode(EnergyPlusData &state,
-                         std::string const &CoilType, // must match coil types in this module
-                         std::string const &CoilName, // must match coil names for the coil type
-                         bool &ErrorsFound            // set to true if problem
-    );
-
-    int GetCoilOutletNode(EnergyPlusData &state,
-                          std::string const &CoilType, // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
-    );
-
-    int getCoilInNodeIndex(EnergyPlusData &state,
-                           int CoilIndex,    // coil index
-                           bool &ErrorsFound // set to true if problem
-    );
-
-    int getCoilOutNodeIndex(EnergyPlusData &state,
-                            int CoilIndex,    // coil index
-                            bool &ErrorsFound // set to true if problem
-    );
+    int GetCoilAirInletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &CoilName, bool &ErrorsFound);
 
     int GetCoilCondenserInletNode(EnergyPlusData &state,
                                   std::string const &CoilType, // must match coil types in this module
@@ -780,7 +762,7 @@ namespace DXCoils {
     );
 
     int GetHPCoolingCoilIndex(EnergyPlusData &state,
-                              std::string const &HeatingCoilType, // Type of DX heating coil used in HP
+                              HVAC::CoilType heatingCoilType, // Type of DX heating coil used in HP
                               std::string const &HeatingCoilName, // Name of DX heating coil used in HP
                               int const HeatingCoilIndex          // Index of DX heating coil used in HP
     );
@@ -791,12 +773,12 @@ namespace DXCoils {
                                 bool &ErrorsFound            // set to true if problem
     );
 
-    Sched::Schedule *GetDXCoilAvailSched(EnergyPlusData &state,
-                                         std::string const &CoilType,                // must match coil types in this module
-                                         std::string const &CoilName,                // must match coil names for the coil type
-                                         bool &ErrorsFound,                          // set to true if problem
-                                         ObjexxFCL::Optional_int_const CoilIndex = _ // Coil index number
-    );
+    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state,
+                                       std::string const &CoilType,                // must match coil types in this module
+                                       std::string const &CoilName,                // must match coil names for the coil type
+                                       bool &ErrorsFound,                          // set to true if problem
+                                       ObjexxFCL::Optional_int_const CoilIndex = _ // Coil index number
+                                       );
 
     Real64 GetDXCoilAirFlow(EnergyPlusData &state,
                             std::string const &CoilType, // must match coil types in this module
@@ -804,10 +786,6 @@ namespace DXCoils {
                             bool &ErrorsFound            // set to true if problem
     );
 
-    int GetDXCoilCapFTCurveIndex(EnergyPlusData &state,
-                                 int const CoilIndex, // coil index pointer
-                                 bool &ErrorsFound    // set to true if problem
-    );
 
     void SetDXCoolingCoilData(
         EnergyPlusData &state,
@@ -836,11 +814,72 @@ namespace DXCoils {
         ObjexxFCL::Optional_string SupplyFanName = _,
         ObjexxFCL::Optional<HVAC::FanType> supplyFanType = _);
 
+    
     void SetCoilSystemHeatingDXFlag(EnergyPlusData &state,
                                     std::string const &CoilType, // must match coil types in this module
                                     std::string const &CoilName  // must match coil names for the coil type
     );
 
+#endif // OLD_API
+  
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int coilNum);
+
+    HVAC::CoilType GetCoilType(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilMinOATCompressor(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int coilNum);
+
+    int GetCoilAirOutletNode(EnergyPlusData &state, int coilNum);
+
+    int GetCoilCondenserInletNode(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilBypassedFlowFrac(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilNumberOfSpeeds(EnergyPlusData &state, int const coilNum);
+  
+    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilAirFlow(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilCapFTCurve(EnergyPlusData &state, int const coilNum);
+
+    void SetCoilHeatingPLFCurve(EnergyPlusData &state, int const DXCoilNum, int HeatingCoilPLFCurvePTR);
+
+    void SetCoilCondenserType(EnergyPlusData &state, int const DXCoilNum, DataHeatBalance::RefrigCondenserType CondenserType); 
+
+    void SetCoilCondenserInletNode(EnergyPlusData &state, int const DXCoilNum, int const condenserInletNode); 
+  
+    void SetCoilMaxOATCrankcaseHeater(EnergyPlusData &state, int const DXCoilNum, Real64 maxOATCrankcaseHeater);
+
+    void SetCoilOATCoolingInfo(EnergyPlusData &state, int const coilNum, Real64 minOAT, Real64 maxOAT); 
+
+    void SetCoilOATHeatingInfo(EnergyPlusData &state, int const DXCoilNum, Real64 minOAT, Real64 maxOAT, HVAC::OATType oatType);
+
+    void SetCoilDefrostInfo(EnergyPlusData &state, int const DXCoilNum,
+                            StandardRatings::DefrostStrat defrostStrategy,
+                            StandardRatings::HPdefrostControl defrostControl,
+                            int defrostEIR,
+                            Real64 defrostFraction,
+                            Real64 maxOATDefrost, 
+                            Real64 defrostCapacity);
+  
+    void SetCoilHeatingCoilPresent(EnergyPlusData &state, int const DXCoilNum, bool heatCoilPresent);
+
+    void SetCoilCoolingCoilPresent(EnergyPlusData &state, int const DXCoilNum, bool coolCoilPresent);
+
+    void SetCoilHeatSizeRatio(EnergyPlusData &state, int const DXCoilNum, Real64 heatSizeRatio);
+
+    void SetCoilTotalCapacity(EnergyPlusData &state, int const DXCoilNum, Real64 totalCapacity);
+
+    void SetCoilSupplyFanInfo(EnergyPlusData &state, int const coilNum, int fanNum, std::string const &fanName, HVAC::FanType fanType);
+  
+    int GetHPCoolingCoilIndex(EnergyPlusData &state, int const coilNum);
+
+    void SetCoilSystemHeatingDXFlag(EnergyPlusData &state, int const coilNum);
+
     void SetCoilSystemCoolingData(EnergyPlusData &state,
                                   std::string const &CoilName, // must match coil names for the coil type
                                   std::string const &CoilSystemName);
diff --git a/src/EnergyPlus/DataAirSystems.hh b/src/EnergyPlus/DataAirSystems.hh
index 53d6f9ee7b8..9d8c2e5bac4 100644
--- a/src/EnergyPlus/DataAirSystems.hh
+++ b/src/EnergyPlus/DataAirSystems.hh
@@ -94,7 +94,7 @@ namespace DataAirSystems {
         // Members
         std::string TypeOf;                                                                // The 'keyWord' identifying  component type
         std::string Name;                                                                  // Component name
-        SimAirServingZones::CompType CompType_Num = SimAirServingZones::CompType::Invalid; // Numeric designator for CompType (TypeOf)
+        SimAirServingZones::CompType compType = SimAirServingZones::CompType::Invalid; // Numeric designator for CompType (TypeOf)
         int CompIndex = 0;                                                                 // Component Index in whatever is using this component
         HVACSystemData *compPointer = nullptr;                                             // pointer to HVAC system
         int FlowCtrl = 0;                                                                  // Component flow control (ACTIVE/PASSIVE)
diff --git a/src/EnergyPlus/DataHVACGlobals.cc b/src/EnergyPlus/DataHVACGlobals.cc
index b488976c4ba..5cbb9ddee16 100644
--- a/src/EnergyPlus/DataHVACGlobals.cc
+++ b/src/EnergyPlus/DataHVACGlobals.cc
@@ -90,123 +90,338 @@ namespace HVAC {
     constexpr std::array<std::string_view, (int)MixerType::Num> mixerTypeLocNames = {"InletSide", "SupplySide"};
     constexpr std::array<std::string_view, (int)MixerType::Num> mixerTypeLocNamesUC = {"INLETSIDE", "SUPPLYSIDE"};
 
-    Array1D_string const cAllCoilTypes(NumAllCoilTypes,
-                                       {"Coil:Cooling:DX:SingleSpeed",
-                                        "Coil:Heating:DX:SingleSpeed",
-                                        "Coil:Cooling:DX:TwoSpeed",
-                                        "CoilSystem:Cooling:DX:HeatExchangerAssisted",
-                                        "Coil:Cooling:DX:TwoStageWithHumidityControlMode",
-                                        "Coil:WaterHeating:AirToWaterHeatPump:Pumped",
-                                        "Coil:WaterHeating:AirToWaterHeatPump:Wrapped",
-                                        "Coil:Cooling:DX:MultiSpeed",
-                                        "Coil:Heating:DX:MultiSpeed",
-                                        "Coil:Heating:Fuel",
-                                        "Coil:Heating:Gas:MultiStage",
-                                        "Coil:Heating:Electric",
-                                        "Coil:Heating:Electric:MultiStage",
-                                        "Coil:Heating:Desuperheater",
-                                        "Coil:Cooling:Water",
-                                        "Coil:Cooling:Water:DetailedGeometry",
-                                        "Coil:Heating:Water",
-                                        "Coil:Heating:Steam",
-                                        "CoilSystem:Cooling:Water:HeatExchangerAssisted",
-                                        "Coil:Cooling:WaterToAirHeatPump:ParameterEstimation",
-                                        "Coil:Heating:WaterToAirHeatPump:ParameterEstimation",
-                                        "Coil:Cooling:WaterToAirHeatPump:EquationFit",
-                                        "Coil:Heating:WaterToAirHeatPump:EquationFit",
-                                        "Coil:Cooling:DX:VariableRefrigerantFlow",
-                                        "Coil:Heating:DX:VariableRefrigerantFlow",
-                                        "Coil:UserDefined",
-                                        "Coil:Cooling:DX:SingleSpeed:ThermalStorage",
-                                        "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit",
-                                        "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit",
-                                        "Coil:Cooling:DX:VariableSpeed",
-                                        "Coil:Heating:DX:VariableSpeed",
-                                        "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed",
-                                        "Coil:Cooling:DX:VariableRefrigerantFlow:FluidTemperatureControl",
-                                        "Coil:Heating:DX:VariableRefrigerantFlow:FluidTemperatureControl",
-                                        "Coil:Cooling:DX",
-                                        "Coil:Cooling:DX:SubcoolReheat",
-                                        "Coil:Cooling:DX:CurveFit:Speed"});
+    constexpr std::array<std::string_view, (int)CoilType::Num> coilTypeNames = {
+        "Coil:Cooling:DX:SingleSpeed",
+        "Coil:Heating:DX:SingleSpeed",
+        "Coil:Cooling:DX:TwoSpeed",
+        "CoilSystem:Cooling:DX:HeatExchangerAssisted",
+        "Coil:Cooling:DX:TwoStageWithHumidityControlMode",
+        "Coil:WaterHeating:AirToWaterHeatPump:Pumped",
+        "Coil:WaterHeating:AirToWaterHeatPump:Wrapped",
+        "Coil:Cooling:DX:MultiSpeed",
+        "Coil:Heating:DX:MultiSpeed",
+        "Coil:Heating:Fuel",
+        "Coil:Heating:Gas:MultiStage",
+        "Coil:Heating:Electric",
+        "Coil:Heating:Electric:MultiStage",
+        "Coil:Heating:Desuperheater",
+        "Coil:Cooling:Water",
+        "Coil:Cooling:Water:DetailedGeometry",
+        "Coil:Heating:Water",
+        "Coil:Heating:Steam",
+        "CoilSystem:Cooling:Water:HeatExchangerAssisted",
+        "Coil:Cooling:WaterToAirHeatPump:ParameterEstimation",
+        "Coil:Heating:WaterToAirHeatPump:ParameterEstimation",
+        "Coil:Cooling:WaterToAirHeatPump:EquationFit",
+        "Coil:Heating:WaterToAirHeatPump:EquationFit",
+        "Coil:Cooling:DX:VariableRefrigerantFlow",
+        "Coil:Heating:DX:VariableRefrigerantFlow",
+        "Coil:UserDefined",
+        "Coil:Cooling:DX:SingleSpeed:ThermalStorage",
+        "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit",
+        "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit",
+        "Coil:Cooling:DX:VariableSpeed",
+        "Coil:Heating:DX:VariableSpeed",
+        "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed",
+        "Coil:Cooling:DX:VariableRefrigerantFlow:FluidTemperatureControl",
+        "Coil:Heating:DX:VariableRefrigerantFlow:FluidTemperatureControl",
+        "Coil:Cooling:DX",
+        "Coil:Cooling:DX:SubcoolReheat",
+        "Coil:Cooling:DX:CurveFit:Speed",
+        "CoilSystem:IntegratedHeatPump:AirSource",
+        "CoilSystem:Cooling:DX",
+        "CoilSystem:Heating:DX"};
+  
+    constexpr std::array<std::string_view, (int)CoilType::Num> coilTypeNamesUC = {
+        "COIL:COOLING:DX:SINGLESPEED",
+        "COIL:HEATING:DX:SINGLESPEED",
+        "COIL:COOLING:DX:TWOSPEED",
+        "COILSYSTEM:COOLING:DX:HEATEXCHANGERASSISTED",
+        "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE",
+        "COIL:WATERHEATING:AIRTOWATERHEATPUMP:PUMPED",
+        "COIL:WATERHEATING:AIRTOWATERHEATPUMP:WRAPPED",
+        "COIL:COOLING:DX:MULTISPEED",
+        "COIL:HEATING:DX:MULTISPEED",
+        "COIL:HEATING:FUEL",
+        "COIL:HEATING:GAS:MULTISTAGE",
+        "COIL:HEATING:ELECTRIC",
+        "COIL:HEATING:ELECTRIC:MULTISTAGE",
+        "COIL:HEATING:DESUPERHEATER",
+        "COIL:COOLING:WATER",
+        "COIL:COOLING:WATER:DETAILEDGEOMETRY",
+        "COIL:HEATING:WATER",
+        "COIL:HEATING:STEAM",
+        "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED",
+        "COIL:COOLING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION",
+        "COIL:HEATING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION",
+        "COIL:COOLING:WATERTOAIRHEATPUMP:EQUATIONFIT",
+        "COIL:HEATING:WATERTOAIRHEATPUMP:EQUATIONFIT",
+        "COIL:COOLING:DX:VARIABLEREFRIGERANTFLOW",
+        "COIL:HEATING:DX:VARIABLEREFRIGERANTFLOW",
+        "COIL:USERDEFINED",
+        "COIL:COOLING:DX:SINGLESPEED:THERMALSTORAGE",
+        "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT",
+        "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT",
+        "COIL:COOLING:DX:VARIABLESPEED",
+        "COIL:HEATING:DX:VARIABLESPEED",
+        "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED",
+        "COIL:COOLING:DX:VARIABLEREFRIGERANTFLOW:FLUIDTEMPERATURECONTROL",
+        "COIL:HEATING:DX:VARIABLEREFRIGERANTFLOW:FLUIDTEMPERATURECONTROL",
+        "COIL:COOLING:DX",
+        "COIL:COOLING:DX:SUBCOOLREHEAT",
+        "COIL:COOLING:DX:CURVEFIT:SPEED",
+        "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE",
+        "COILSYSTEM:COOLING:DX",
+        "COILSYSTEM:HEATING:DX"};
 
-    Array1D_string const cCoolingCoilTypes(NumAllCoilTypes,
-                                           {"Coil:Cooling:DX:SingleSpeed",
-                                            "",
-                                            "Coil:Cooling:DX:TwoSpeed",
-                                            "CoilSystem:Cooling:DX:HeatExchangerAssisted",
-                                            "Coil:Cooling:DX:TwoStageWithHumidityControlMode",
-                                            "",
-                                            "",
-                                            "Coil:Cooling:DX:MultiSpeed",
-                                            "",
-                                            "",
-                                            "",
-                                            "",
-                                            "",
-                                            "",
-                                            "Coil:Cooling:Water",
-                                            "Coil:Cooling:Water:DetailedGeometry",
-                                            "",
-                                            "",
-                                            "CoilSystem:Cooling:Water:HeatExchangerAssisted",
-                                            "Coil:Cooling:WaterToAirHeatPump:ParameterEstimation",
-                                            "",
-                                            "Coil:Cooling:WaterToAirHeatPump:EquationFit",
-                                            "",
-                                            "Coil:Cooling:DX:VariableRefrigerantFlow",
-                                            "",
-                                            "",
-                                            "Coil:Cooling:DX:SingleSpeed:ThermalStorage",
-                                            "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit",
-                                            "",
-                                            "Coil:Cooling:DX:VariableSpeed",
-                                            "",
-                                            "",
-                                            "Coil:Cooling:DX:VariableRefrigerantFlow:FluidTemperatureControl",
-                                            "",
-                                            "Coil:Cooling:DX",
-                                            "Coil:Cooling:DX:SubcoolReheat",
-                                            "Coil:Cooling:DX:CurveFit:Speed"});
+    constexpr std::array<bool, (int)CoilType::Num> coilTypeIsCooling = {
+        true, // DXCoolingSingleSpeed,
+        false, // DXHeatingEmpirical,
+        true, // DXCoolingTwoSpeed,
+        true, // DXCoolingHXAssisted,
+        true, // DXCoolingTwoStageWHumControl,
+        false, // DXHeatPumpWaterHeaterPumped,
+        false, // DXHeatPumpWaterHeaterWrapped,
+        true, // DXMultiSpeedCooling,
+        false, // DXMultiSpeedHeating,
+        false, // HeatingGasOrOtherFuel,
+        false, // HeatingGasMultiStage,
+        false, // HeatingElectric,
+        false, // HeatingElectricMultiStage,
+        false, // HeatingDesuperheater,
+        true, // CoolingWater,
+        true, // CoolingWaterDetailed,
+        false, // HeatingWater,
+        false, // HeatingSteam,
+        true, // WaterCoolingHXAssisted,
+        true, // CoolingWaterToAirHP,
+        false, // HeatingWaterToAirHP,
+        true, // CoolingWaterToAirHPSimple,
+        false, // HeatingWaterToAirHPSimple,
+        true, // VRFCooling,
+        false, // VRFHeating,
+        false, // UserDefined,
+        true, // DXPackagedThermalStorageCooling,
+        true, // CoolingWaterToAirHPVSEquationFit,
+        false, // HeatingWaterToAirHPVSEquationFit,
+        true, // CoolingAirToAirVariableSpeed,
+        false, // HeatingAirToAirVariableSpeed,
+        false, // DXHeatPumpWaterHeaterVariableSpeed,
+        true, // VRFFluidTCtrlCooling,
+        false, // VRFFluidTCtrlHeating,
+        true, // CoolingDX,
+        true, // DXSubcoolReheat,
+        true, // CoolingDXCurveFit,
+        true, // IHPAirSource,
+        true, // CoolingSystemDX,
+        false // HeatingSystemDX
+    };
+  
+    constexpr std::array<bool, (int)CoilType::Num> coilTypeIsHeating = {
+        false, // CoolingDXSingleSpeed,
+        true, // HeatingDXSingleSpeed,
+        false, // CoolingDXTwoSpeed,
+        false, // DXCoolingHXAssisted,
+        false, // DXCoolingTwoStageWHumControl,
+        true, // DXHeatPumpWaterHeaterPumped,
+        true, // DXHeatPumpWaterHeaterWrapped,
+        false, // CoolingDXMultiSpeed,
+        true, // HeatingDXMultiSpeed,
+        true, // HeatingGasOrOtherFuel,
+        true, // HeatingGasMultiStage,
+        true, // HeatingElectric,
+        true, // HeatingElectricMultiStage,
+        true, // HeatingDesuperheater,
+        false, // CoolingWater,
+        false, // CoolingWaterDetailed,
+        true, // HeatingWater,
+        true, // HeatingSteam,
+        false, // WaterCoolingHXAssisted,
+        false, // CoolingWaterToAirHP,
+        true, // HeatingWaterToAirHP,
+        false, // CoolingWaterToAirHPSimple,
+        true, // HeatingWaterToAirHPSimple,
+        false, // CoolingVRF,
+        true, // HeatingVRF,
+        false, // UserDefined,
+        false, // CoolingDXPackagedThermalStorage,
+        false, // CoolingWAHPVariableSpeedEquationFit,
+        true, // HeatingWAHPVariableSpeedEquationFit,
+        false, // CoolingDXVariableSpeed,
+        true, // HeatingDXVariableSpeed,
+        true, // WaterHeatingAWHPVariableSpeed,
+        false, // CoolingVRFFluidTCtrl,
+        true, // HeatingVRFFluidTCtrl,
+        false, // CoolingDX,
+        false, // DXSubcoolReheat,
+        false, // CoolingDXCurveFit
+        true, // IHP air source
+        false, // CoolingSystemDX
+        true // HeatingSystemDX
+    };
 
-    Array1D_string const cHeatingCoilTypes(NumAllCoilTypes,
-                                           {"",
-                                            "Coil:Heating:DX:SingleSpeed",
-                                            "",
-                                            "",
-                                            "",
-                                            "Coil:WaterHeating:AirToWaterHeatPump:Pumped",
-                                            "Coil:WaterHeating:AirToWaterHeatPump:Wrapped",
-                                            "",
-                                            "Coil:Heating:DX:MultiSpeed",
-                                            "Coil:Heating:Fuel",
-                                            "Coil:Heating:Gas:MultiStage",
-                                            "Coil:Heating:Electric",
-                                            "Coil:Heating:Electric:MultiStage",
-                                            "Coil:Heating:Desuperheater",
-                                            "",
-                                            "",
-                                            "Coil:Heating:Water",
-                                            "Coil:Heating:Steam",
-                                            "",
-                                            "",
-                                            "Coil:Heating:WaterToAirHeatPump:ParameterEstimation",
-                                            "",
-                                            "Coil:Heating:WaterToAirHeatPump:EquationFit",
-                                            "",
-                                            "Coil:Heating:DX:VariableRefrigerantFlow",
-                                            "",
-                                            "",
-                                            "",
-                                            "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit",
-                                            "",
-                                            "Coil:Heating:DX:VariableSpeed",
-                                            "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed",
-                                            "",
-                                            "Coil:Heating:DX:VariableRefrigerantFlow:FluidTemperatureControl",
-                                            "",
-                                            "",
-                                            ""});
+    constexpr std::array<bool, (int)CoilType::Num> coilTypeIsHeatPump = {
+        false, // DXCoolingSingleSpeed,
+        true, // HeatingDXSingleSpeed,
+        false, // DXCoolingTwoSpeed,
+        false, // DXCoolingHXAssisted,
+        false, // DXCoolingTwoStageWHumControl,
+        false, // HeatPumpWaterHeaterDXPumped,
+        false, // HeatPumpWaterHeaterDXWrapped,
+        false, // CoolingDXMultiSpeed,
+        true, // HeatingDXMultiSpeed,
+        false, // HeatingGasOrOtherFuel,
+        false, // HeatingGasMultiStage,
+        false, // HeatingElectric,
+        false, // HeatingElectricMultiStage,
+        false, // HeatingDesuperheater,
+        false, // CoolingWater,
+        false, // CoolingWaterDetailed,
+        false, // HeatingWater,
+        false, // HeatingSteam,
+        false, // CoolingWaterHXAssisted,
+        false, // CoolingWAHP,
+        true, // HeatingWAHP,
+        false, // CoolingWAHPSimple,
+        true, // HeatingWAHPSimple,
+        false, // CoolingVRF,
+        false, // HeatingVRF,
+        false, // UserDefined,
+        false, // CoolingDXPackagedThermalStorage,
+        false, // CoolingWAHPVariableSpeedEquationFit,
+        true, // HeatingWAHPVariableSpeedEquationFit,
+        false, // CoolingDXVariableSpeed,
+        true, // HeatingDXVariableSpeed,
+        false, // WaterHeatingAWHPVariableSpeed,
+        false, // CoolingVRFFluidTCtrl,
+        false, // HeatingVRFFluidTCtrl,
+        false, // CoolingDX,
+        false, // DXSubcoolReheat,
+        false, // DXCurveFitSpeed
+        true, // IHPAirSource
+        true, // CoolingSystemDX
+        true, // HeatingSystemDX
+    };
+  
+#ifdef GET_OUT
+    Array1D_string const cAllCoilTypes(NumAllCoilTypes, {
+        "Coil:Cooling:DX:SingleSpeed",
+        "Coil:Heating:DX:SingleSpeed",
+        "Coil:Cooling:DX:TwoSpeed",
+        "CoilSystem:Cooling:DX:HeatExchangerAssisted",
+        "Coil:Cooling:DX:TwoStageWithHumidityControlMode",
+        "Coil:WaterHeating:AirToWaterHeatPump:Pumped",
+        "Coil:WaterHeating:AirToWaterHeatPump:Wrapped",
+        "Coil:Cooling:DX:MultiSpeed",
+        "Coil:Heating:DX:MultiSpeed",
+        "Coil:Heating:Fuel",
+        "Coil:Heating:Gas:MultiStage",
+        "Coil:Heating:Electric",
+        "Coil:Heating:Electric:MultiStage",
+        "Coil:Heating:Desuperheater",
+        "Coil:Cooling:Water",
+        "Coil:Cooling:Water:DetailedGeometry",
+        "Coil:Heating:Water",
+        "Coil:Heating:Steam",
+        "CoilSystem:Cooling:Water:HeatExchangerAssisted",
+        "Coil:Cooling:WaterToAirHeatPump:ParameterEstimation",
+        "Coil:Heating:WaterToAirHeatPump:ParameterEstimation",
+        "Coil:Cooling:WaterToAirHeatPump:EquationFit",
+        "Coil:Heating:WaterToAirHeatPump:EquationFit",
+        "Coil:Cooling:DX:VariableRefrigerantFlow",
+        "Coil:Heating:DX:VariableRefrigerantFlow",
+        "Coil:UserDefined",
+        "Coil:Cooling:DX:SingleSpeed:ThermalStorage",
+        "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit",
+        "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit",
+        "Coil:Cooling:DX:VariableSpeed",
+        "Coil:Heating:DX:VariableSpeed",
+        "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed",
+        "Coil:Cooling:DX:VariableRefrigerantFlow:FluidTemperatureControl",
+        "Coil:Heating:DX:VariableRefrigerantFlow:FluidTemperatureControl",
+        "Coil:Cooling:DX",
+        "Coil:Cooling:DX:SubcoolReheat",
+        "Coil:Cooling:DX:CurveFit:Speed"});
+
+    Array1D_string const cCoolingCoilTypes(NumAllCoilTypes, {
+        "Coil:Cooling:DX:SingleSpeed",
+        "",
+        "Coil:Cooling:DX:TwoSpeed",
+        "CoilSystem:Cooling:DX:HeatExchangerAssisted",
+        "Coil:Cooling:DX:TwoStageWithHumidityControlMode",
+        "",
+        "",
+        "Coil:Cooling:DX:MultiSpeed",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "Coil:Cooling:Water",
+        "Coil:Cooling:Water:DetailedGeometry",
+        "",
+        "",
+        "CoilSystem:Cooling:Water:HeatExchangerAssisted",
+        "Coil:Cooling:WaterToAirHeatPump:ParameterEstimation",
+        "",
+        "Coil:Cooling:WaterToAirHeatPump:EquationFit",
+        "",
+        "Coil:Cooling:DX:VariableRefrigerantFlow",
+        "",
+        "",
+        "Coil:Cooling:DX:SingleSpeed:ThermalStorage",
+        "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit",
+        "",
+        "Coil:Cooling:DX:VariableSpeed",
+        "",
+        "",
+        "Coil:Cooling:DX:VariableRefrigerantFlow:FluidTemperatureControl",
+        "",
+        "Coil:Cooling:DX",
+        "Coil:Cooling:DX:SubcoolReheat",
+        "Coil:Cooling:DX:CurveFit:Speed"});
+  
+    Array1D_string const cHeatingCoilTypes(NumAllCoilTypes, {
+        "",
+        "Coil:Heating:DX:SingleSpeed",
+        "",
+        "",
+        "",
+        "Coil:WaterHeating:AirToWaterHeatPump:Pumped",
+        "Coil:WaterHeating:AirToWaterHeatPump:Wrapped",
+        "",
+        "Coil:Heating:DX:MultiSpeed",
+        "Coil:Heating:Fuel",
+        "Coil:Heating:Gas:MultiStage",
+        "Coil:Heating:Electric",
+        "Coil:Heating:Electric:MultiStage",
+        "Coil:Heating:Desuperheater",
+        "",
+        "",
+        "Coil:Heating:Water",
+        "Coil:Heating:Steam",
+        "",
+        "",
+        "Coil:Heating:WaterToAirHeatPump:ParameterEstimation",
+        "",
+        "Coil:Heating:WaterToAirHeatPump:EquationFit",
+        "",
+        "Coil:Heating:DX:VariableRefrigerantFlow",
+        "",
+        "",
+        "",
+        "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit",
+        "",
+        "Coil:Heating:DX:VariableSpeed",
+        "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed",
+        "",
+        "Coil:Heating:DX:VariableRefrigerantFlow:FluidTemperatureControl",
+        "",
+        "",
+        ""});
 
+#endif // GET_OUT
     constexpr std::array<std::string_view, (int)HXType::Num> hxTypeNames = {
         "HeatExchanger:AirToAir:FlatPlate", "HeatExchanger:AirToAir:SensibleAndLatent", "HeatExchanger:Desiccant:BalancedFlow"};
 
diff --git a/src/EnergyPlus/DataHVACGlobals.hh b/src/EnergyPlus/DataHVACGlobals.hh
index 48f96bcefa2..ef4827b31b8 100644
--- a/src/EnergyPlus/DataHVACGlobals.hh
+++ b/src/EnergyPlus/DataHVACGlobals.hh
@@ -221,15 +221,15 @@ namespace HVAC {
     enum class CoilType
     {
         Invalid = -1,
-        DXCoolingSingleSpeed,
-        DXHeatingEmpirical,
-        DXCoolingTwoSpeed,
-        DXCoolingHXAssisted,
-        DXCoolingTwoStageWHumControl,
-        DXHeatPumpWaterHeaterPumped,
-        DXHeatPumpWaterHeaterWrapped,
-        DXMultiSpeedCooling,
-        DXMultiSpeedHeating,
+        CoolingDXSingleSpeed,
+        HeatingDXSingleSpeed,
+        CoolingDXTwoSpeed,
+        CoolingDXHXAssisted,
+        CoolingDXTwoStageWHumControl,
+        WaterHeatingDXPumped,
+        WaterHeatingDXWrapped,
+        CoolingDXMultiSpeed,
+        HeatingDXMultiSpeed,
         HeatingGasOrOtherFuel,
         HeatingGasMultiStage,
         HeatingElectric,
@@ -239,66 +239,40 @@ namespace HVAC {
         CoolingWaterDetailed,
         HeatingWater,
         HeatingSteam,
-        WaterCoolingHXAssisted,
-        CoolingWaterToAirHP,
-        HeatingWaterToAirHP,
-        CoolingWaterToAirHPSimple,
-        HeatingWaterToAirHPSimple,
-        VRFCooling,
-        VRFHeating,
+        CoolingWaterHXAssisted,
+        CoolingWAHP,
+        HeatingWAHP,
+        CoolingWAHPSimple,
+        HeatingWAHPSimple,
+        CoolingVRF,
+        HeatingVRF,
         UserDefined,
-        DXPackagedThermalStorageCooling,
-        CoolingWaterToAirHPVSEquationFit,
-        HeatingWaterToAirHPVSEquationFit,
-        CoolingAirToAirVariableSpeed,
-        HeatingAirToAirVariableSpeed,
-        DXHeatPumpWaterHeaterVariableSpeed,
-        VRFFluidTCtrlCooling,
-        VRFFluidTCtrlHeating,
-        DXCooling,
+        CoolingDXPackagedThermalStorage,
+        CoolingWAHPVariableSpeedEquationFit,
+        HeatingWAHPVariableSpeedEquationFit,
+        CoolingDXVariableSpeed,
+        HeatingDXVariableSpeed,
+        WaterHeatingAWHPVariableSpeed,
+        CoolingVRFFluidTCtrl,
+        HeatingVRFFluidTCtrl,
+        CoolingDX,
         DXSubcoolReheat,
-        DXCurveFitSpeed,
+        CoolingDXCurveFit,
+        IHPAirSource,
+        CoolingSystemDX,
+        HeatingSystemDX,
         Num
     };
-    static constexpr std::array<std::string_view, static_cast<int>(CoilType::Num)> coilTypeNamesUC = {
-        "COIL:COOLING:DX:SINGLESPEED",
-        "COIL:HEATING:DX:SINGLESPEED",
-        "COIL:COOLING:DX:TWOSPEED",
-        "COILSYSTEM:COOLING:DX:HEATEXCHANGERASSISTED",
-        "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE",
-        "COIL:WATERHEATING:AIRTOWATERHEATPUMP:PUMPED",
-        "COIL:WATERHEATING:AIRTOWATERHEATPUMP:WRAPPED",
-        "COIL:COOLING:DX:MULTISPEED",
-        "COIL:HEATING:DX:MULTISPEED",
-        "COIL:HEATING:FUEL",
-        "COIL:HEATING:GAS:MULTISTAGE",
-        "COIL:HEATING:ELECTRIC",
-        "COIL:HEATING:ELECTRIC:MULTISTAGE",
-        "COIL:HEATING:DESUPERHEATER",
-        "COIL:COOLING:WATER",
-        "COIL:COOLING:WATER:DETAILEDGEOMETRY",
-        "COIL:HEATING:WATER",
-        "COIL:HEATING:STEAM",
-        "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED",
-        "COIL:COOLING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION",
-        "COIL:HEATING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION",
-        "COIL:COOLING:WATERTOAIRHEATPUMP:EQUATIONFIT",
-        "COIL:HEATING:WATERTOAIRHEATPUMP:EQUATIONFIT",
-        "COIL:COOLING:DX:VARIABLEREFRIGERANTFLOW",
-        "COIL:HEATING:DX:VARIABLEREFRIGERANTFLOW",
-        "COIL:USERDEFINED",
-        "COIL:COOLING:DX:SINGLESPEED:THERMALSTORAGE",
-        "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT",
-        "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT",
-        "COIL:COOLING:DX:VARIABLESPEED",
-        "COIL:HEATING:DX:VARIABLESPEED",
-        "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED",
-        "COIL:COOLING:DX:VARIABLEREFRIGERANTFLOW:FLUIDTEMPERATURECONTROL",
-        "COIL:HEATING:DX:VARIABLEREFRIGERANTFLOW:FLUIDTEMPERATURECONTROL",
-        "COIL:COOLING:DX",
-        "COIL:COOLING:DX:SUBCOOLREHEAT",
-        "COIL:COOLING:DX:CURVEFIT:SPEED"};
 
+    extern const std::array<std::string_view, (int)CoilType::Num> coilTypeNames;
+    extern const std::array<std::string_view, (int)CoilType::Num> coilTypeNamesUC;
+
+    extern const std::array<bool, (int)CoilType::Num> coilTypeIsHeating; 
+    extern const std::array<bool, (int)CoilType::Num> coilTypeIsCooling;
+
+    extern const std::array<bool, (int)CoilType::Num> coilTypeIsHeatPump;
+  
+#ifdef GET_OUT
     // parameters describing coil types
     int constexpr NumAllCoilTypes(37);
     int constexpr CoilDX_CoolingSingleSpeed(1);
@@ -338,7 +312,8 @@ namespace HVAC {
     int constexpr CoilDX_Cooling(35);
     //    int constexpr CoilDX_SubcoolReheat(36);
     int constexpr CoilDX_CurveFit_Speed(37);
-
+#endif // GET_OUT
+  
     enum class CoilMode
     {
         Invalid = -1,
@@ -348,6 +323,54 @@ namespace HVAC {
         Num
     };
 
+    enum class HeatReclaimType // reclaim heat object types
+    {
+        Invalid = -1,
+        RefrigeratedCaseCompressorRack,
+        RefrigeratedCaseCondenserAirCooled,
+        RefrigeratedCaseCondenserEvaporativeCooled,
+        RefrigeratedCaseCondenserWaterCooled,
+        CoilCoolDXSingleSpeed,
+        CoilCoolDXTwoSpeed,
+        CoilCoolDXMultiSpeed,
+        CoilCoolDXMultiMode,
+        CoilCoolDXVariableSpeed,
+        CoilCoolDX,
+        CoilCoolWAHPEquationFit,
+        CoilCoolWAHPVariableSpeedEquationFit,
+        Num
+    };
+
+    constexpr std::array<std::string_view, (int)HeatReclaimType::Num> heatReclaimTypeNames = {
+        "Refrigeration:CompressorRack",
+        "Refrigeration:Condenser:AirCooled", 
+        "Refrigeration:Condenser:EvaporativeCooled",
+        "Refrigeration:Condenser:WaterCooled",
+        "Coil:Cooling:DX:SingleSpeed",
+        "Coil:Cooling:DX:TwoSpeed",
+        "Coil:Cooling:DX:MultiSpeed",
+        "Coil:Cooling:DX:TwoStageWithHumidityControlMode",
+        "Coil:Cooling:DX:VariableSpeed",
+        "Coil:Cooling:DX",
+        "Coil:Cooling:WaterToAirHeatPump:EquationFit",        
+        "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit"        
+    };
+
+    constexpr std::array<std::string_view, (int)HeatReclaimType::Num> heatReclaimTypeNamesUC = {
+        "REFRIGERATION:COMPRESSORRACK",
+        "REFRIGERATION:CONDENSER:AIRCOOLED", 
+        "REFRIGERATION:CONDENSER:EVAPORATIVECOOLED",
+        "REFRIGERATION:CONDENSER:WATERCOOLED",
+        "COIL:COOLING:DX:SINGLESPEED",
+        "COIL:COOLING:DX:TWOSPEED",
+        "COIL:COOLING:DX:MULTISPEED",
+        "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE",
+        "COIL:COOLING:DX:VARIABLESPEED",
+        "COIL:COOLING:DX",
+        "COIL:COOLING:WATERTOAIRHEATPUMP:EQUATIONFIT",
+        "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT"
+    };
+  
     enum class WaterFlow
     {
         Invalid = -1,
@@ -435,7 +458,10 @@ namespace HVAC {
 
     int constexpr MaxSpeedLevels = 10;
 
+#ifdef GET_OUT  
     extern Array1D_string const cAllCoilTypes;
+#endif // GET_OUT
+  
     extern Array1D_string const cCoolingCoilTypes;
     extern Array1D_string const cHeatingCoilTypes;
 
diff --git a/src/EnergyPlus/DataHeatBalance.hh b/src/EnergyPlus/DataHeatBalance.hh
index 6ac249f6dd9..01370af087a 100644
--- a/src/EnergyPlus/DataHeatBalance.hh
+++ b/src/EnergyPlus/DataHeatBalance.hh
@@ -60,6 +60,7 @@
 #include <EnergyPlus/Data/BaseData.hh>
 #include <EnergyPlus/DataGlobalConstants.hh>
 #include <EnergyPlus/DataGlobals.hh>
+#include <EnergyPlus/DataHVACGlobals.hh>
 #include <EnergyPlus/DataSurfaces.hh>
 #include <EnergyPlus/DataVectorTypes.hh>
 #include <EnergyPlus/DataWindowEquivalentLayer.hh>
@@ -1380,7 +1381,7 @@ namespace DataHeatBalance {
     {
         // Members
         std::string Name;                                         // Name of Coil
-        std::string SourceType;                                   // SourceType for Coil
+        std::string SourceType;
         Real64 AvailCapacity = 0.0;                               // Total available heat reclaim capacity
         Real64 ReclaimEfficiencyTotal = 0.0;                      // Total reclaimed portion
         Real64 WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0; // total reclaimed heat by water heating desuperheater coils
diff --git a/src/EnergyPlus/DataSizing.cc b/src/EnergyPlus/DataSizing.cc
index 54ca2c21553..67fbda44c0e 100644
--- a/src/EnergyPlus/DataSizing.cc
+++ b/src/EnergyPlus/DataSizing.cc
@@ -468,7 +468,7 @@ void resetHVACSizingGlobals(EnergyPlusData &state,
     state.dataSize->DataCoilSizingAirInHumRat = 0.0;
     state.dataSize->DataCoilSizingAirOutTemp = 0.0;
     state.dataSize->DataCoilSizingAirOutHumRat = 0.0;
-    state.dataSize->DataCoolCoilType = -1;
+    state.dataSize->DataCoolCoilType = HVAC::CoilType::Invalid;
     state.dataSize->DataCoolCoilIndex = -1;
 
     // These zone specific sizing variables are set in zone equipment to use for sizing.
diff --git a/src/EnergyPlus/DataSizing.hh b/src/EnergyPlus/DataSizing.hh
index e790320ffac..c8895ffac5b 100644
--- a/src/EnergyPlus/DataSizing.hh
+++ b/src/EnergyPlus/DataSizing.hh
@@ -1294,7 +1294,7 @@ struct SizingData : BaseGlobalStruct
     int DataFanIndex = -1;                                // Fan index used during sizing
     HVAC::FanPlace DataFanPlacement = HVAC::FanPlace::Invalid; // identifies location of fan wrt coil
     int DataDXSpeedNum = 0;
-    int DataCoolCoilType = -1;
+    HVAC::CoilType DataCoolCoilType = HVAC::CoilType::Invalid; // Why the 'Data' prefix?
     int DataCoolCoilIndex = -1;
     EPVector<DataSizing::OARequirementsData> OARequirements;
     EPVector<DataSizing::ZoneAirDistributionData> ZoneAirDistribution;
diff --git a/src/EnergyPlus/DesiccantDehumidifiers.cc b/src/EnergyPlus/DesiccantDehumidifiers.cc
index 16f1b091016..32b1e9ceca6 100644
--- a/src/EnergyPlus/DesiccantDehumidifiers.cc
+++ b/src/EnergyPlus/DesiccantDehumidifiers.cc
@@ -245,7 +245,6 @@ namespace DesiccantDehumidifiers {
         bool errFlag;                   // local error flag
         std::string RegenCoilType;      // Regen heating coil type
         std::string RegenCoilName;      // Regen heating coil name
-        bool RegairHeatingCoilFlag;     // local error flag
 
         int TotalArgs = 0;
 
@@ -368,125 +367,51 @@ namespace DesiccantDehumidifiers {
             desicDehum.NomProcAirVolFlow = Numbers(2);
             desicDehum.NomProcAirVel = Numbers(3);
 
-            desicDehum.RegenCoilType = Alphas(8);
+            desicDehum.regenCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(8)));
             desicDehum.RegenCoilName = Alphas(9);
 
             desicDehum.regenFanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(10)));
             assert(desicDehum.regenFanType != HVAC::FanType::Invalid);
 
-            RegenCoilType = Alphas(8);
-            RegenCoilName = Alphas(9);
-
-            if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Electric") ||
-                Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Fuel")) {
-                if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Electric")) desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingElectric;
-                if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Fuel")) desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingGasOrOtherFuel;
-                ValidateComponent(state, desicDehum.RegenCoilType, desicDehum.RegenCoilName, ErrorsFound2, CurrentModuleObject + '=' + Alphas(1));
-                if (ErrorsFound2) ErrorsFound = true;
-                HeatingCoils::GetCoilIndex(state, desicDehum.RegenCoilName, desicDehum.RegenCoilIndex, ErrorsFound2);
-                if (ErrorsFound2) ErrorsFound = true;
-
-            } else if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Water")) {
-                desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingWater;
-                ValidateComponent(state, RegenCoilType, RegenCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            if (desicDehum.regenCoilType == HVAC::CoilType::HeatingElectric ||
+                desicDehum.regenCoilType == HVAC::CoilType::HeatingGasOrOtherFuel) {
+                desicDehum.RegenCoilNum = HeatingCoils::GetCoilIndex(state, desicDehum.RegenCoilName);
+                if (desicDehum.RegenCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), desicDehum.RegenCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-                    errFlag = false;
-                    desicDehum.RegenCoilIndex = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", RegenCoilName, errFlag);
-                    if (desicDehum.RegenCoilIndex == 0) {
-                        ShowSevereError(state, format("{}{} illegal {} = {}", RoutineName, CurrentModuleObject, cAlphaFields(9), RegenCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil Hot water Inlet or control Node number
-                    errFlag = false;
-                    desicDehum.CoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Regeneration Heating Coil hot water max volume flow rate
-                    errFlag = false;
-                    desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Regeneration Heating Coil Inlet Node
-                    errFlag = false;
-                    int RegenCoilAirInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                    desicDehum.RegenCoilInletNode = RegenCoilAirInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Regeneration Heating Coil Outlet Node
-                    errFlag = false;
-                    int RegenCoilAirOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                    desicDehum.RegenCoilOutletNode = RegenCoilAirOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
                 }
-            } else if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Steam")) {
-                desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingSteam;
-                ValidateComponent(state, Alphas(8), RegenCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                
+            } else if (desicDehum.regenCoilType == HVAC::CoilType::HeatingWater) {
+                desicDehum.RegenCoilNum = WaterCoils::GetCoilIndex(state, desicDehum.RegenCoilName);
+                if (desicDehum.RegenCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), desicDehum.RegenCoilName);
                     ErrorsFound = true;
-                } else { // mine data from the regeneration heating coil object
-
-                    errFlag = false;
-                    desicDehum.RegenCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", RegenCoilName, errFlag);
-                    if (desicDehum.RegenCoilIndex == 0) {
-                        ShowSevereError(state, format("{}{} illegal {} = {}", RoutineName, CurrentModuleObject, cAlphaFields(9), RegenCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
-
+                } else {
+                    desicDehum.CoilControlNode = WaterCoils::GetCoilWaterInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, desicDehum.RegenCoilNum);
+                    desicDehum.RegenCoilInletNode = WaterCoils::GetCoilAirInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.RegenCoilOutletNode = WaterCoils::GetCoilAirOutletNode(state, desicDehum.RegenCoilNum);
+                }
+                
+            } else if (desicDehum.regenCoilType == HVAC::CoilType::HeatingSteam) { 
+                desicDehum.RegenCoilNum = SteamCoils::GetCoilIndex(state, desicDehum.RegenCoilName);
+                if (desicDehum.RegenCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), desicDehum.RegenCoilName);
+                    ErrorsFound = true;
+                } else {
                     // Get the regeneration Heating Coil steam inlet node number
-                    errFlag = false;
-                    desicDehum.CoilControlNode = SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", RegenCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the regeneration heating Coil steam max volume flow rate
-                    desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilIndex, errFlag);
+                    desicDehum.CoilControlNode = SteamCoils::GetCoilSteamInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilNum);
                     if (desicDehum.MaxCoilFluidFlow > 0.0) {
                         Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, dehumidifierDesiccantNoFans);
                         desicDehum.MaxCoilFluidFlow *= SteamDensity;
                     }
 
-                    // Get the regeneration heating Coil Inlet Node
-                    errFlag = false;
-                    int RegenCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, desicDehum.RegenCoilIndex, RegenCoilName, errFlag);
-                    desicDehum.RegenCoilInletNode = RegenCoilAirInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the regeneration heating Coil Outlet Node
-                    errFlag = false;
-                    int RegenCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, desicDehum.RegenCoilIndex, RegenCoilName, errFlag);
-                    desicDehum.RegenCoilOutletNode = RegenCoilAirOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                        ErrorsFound = true;
-                    }
+                    desicDehum.RegenCoilInletNode = SteamCoils::GetCoilAirInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.RegenCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, desicDehum.RegenCoilNum);
                 }
             } else {
-                ShowSevereError(state, format("{}{} = {}", RoutineName, CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(8), desicDehum.RegenCoilType));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(8), Alphas(8));
                 ErrorsFound = true;
             }
 
@@ -671,28 +596,21 @@ namespace DesiccantDehumidifiers {
                 ErrorsFound = true;
             }
 
-            desicDehum.HXType = Alphas(3);
-            desicDehum.HXName = Alphas(4);
-
-            if (!Util::SameString(desicDehum.HXType, "HeatExchanger:Desiccant:BalancedFlow")) {
-                ShowWarningError(state, format("{} = \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                ShowContinueError(state, format("Invalid {} = {}", cAlphaFields(3), desicDehum.HXType));
+            desicDehum.hxType = static_cast<HVAC::HXType>(getEnumValue(HVAC::hxTypeNamesUC, Alphas(3)));
+            if (desicDehum.hxType != HVAC::HXType::Desiccant_Balanced) { 
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(3), Alphas(3));
                 ErrorsFoundGeneric = true;
-            } else {
-                desicDehum.HXTypeNum = BalancedHX;
-            }
+              }
 
-            ErrorsFound2 = false;
-            ValidateComponent(state, desicDehum.HXType, desicDehum.HXName, ErrorsFound2, desicDehum.DehumType + " = \"" + desicDehum.Name + "\"");
-            if (ErrorsFound2) ErrorsFoundGeneric = true;
-
-            ErrorsFound2 = false;
-            desicDehum.HXProcInNode = HeatRecovery::GetSecondaryInletNode(state, desicDehum.HXName, ErrorsFound2);
-            if (ErrorsFound2) {
-                ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
+            desicDehum.hxName = Alphas(4);
+            desicDehum.hxNum = HeatRecovery::GetHeatExchangerIndex(state, desicDehum.hxName);
+            if (desicDehum.hxNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(4), desicDehum.hxName);
                 ErrorsFoundGeneric = true;
             }
-
+            
+            desicDehum.HXProcInNode = HeatRecovery::GetSecondaryInletNode(state, desicDehum.hxNum);
+            
             std::string ProcAirInlet = state.dataLoopNodes->NodeID(desicDehum.HXProcInNode);
 
             desicDehum.ProcAirInNode = NodeInputManager::GetOnlySingleNode(state,
@@ -705,12 +623,7 @@ namespace DesiccantDehumidifiers {
                                                                            NodeInputManager::CompFluidStream::Primary,
                                                                            DataLoopNode::ObjectIsParent);
 
-            ErrorsFound2 = false;
-            desicDehum.HXProcOutNode = HeatRecovery::GetSecondaryOutletNode(state, desicDehum.HXName, ErrorsFound2);
-            if (ErrorsFound2) {
-                ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                ErrorsFoundGeneric = true;
-            }
+            desicDehum.HXProcOutNode = HeatRecovery::GetSecondaryOutletNode(state, desicDehum.hxNum);
 
             std::string ProcAirOutlet = state.dataLoopNodes->NodeID(desicDehum.HXProcOutNode);
 
@@ -726,19 +639,8 @@ namespace DesiccantDehumidifiers {
 
             BranchNodeConnections::TestCompSet(state, desicDehum.DehumType, desicDehum.Name, ProcAirInlet, ProcAirOutlet, "Process Air Nodes");
 
-            ErrorsFound2 = false;
-            desicDehum.HXRegenInNode = HeatRecovery::GetSupplyInletNode(state, desicDehum.HXName, ErrorsFound2);
-            if (ErrorsFound2) {
-                ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                ErrorsFoundGeneric = true;
-            }
-
-            ErrorsFound2 = false;
-            desicDehum.HXRegenOutNode = HeatRecovery::GetSupplyOutletNode(state, desicDehum.HXName, ErrorsFound2);
-            if (ErrorsFound2) {
-                ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                ErrorsFoundGeneric = true;
-            }
+            desicDehum.HXRegenInNode = HeatRecovery::GetSupplyInletNode(state, desicDehum.hxNum);
+            desicDehum.HXRegenOutNode = HeatRecovery::GetSupplyOutletNode(state, desicDehum.hxNum);
 
             desicDehum.ControlNodeNum = NodeInputManager::GetOnlySingleNode(state,
                                                                             Alphas(5),
@@ -761,7 +663,8 @@ namespace DesiccantDehumidifiers {
 
             desicDehum.RegenFanName = Alphas(7);
 
-            if (desicDehum.regenFanType == HVAC::FanType::OnOff || desicDehum.regenFanType == HVAC::FanType::Constant ||
+            if (desicDehum.regenFanType == HVAC::FanType::OnOff ||
+                desicDehum.regenFanType == HVAC::FanType::Constant ||
                 desicDehum.regenFanType == HVAC::FanType::SystemModel) {
                 ErrorsFound2 = false;
                 ValidateComponent(state,
@@ -794,63 +697,32 @@ namespace DesiccantDehumidifiers {
                 desicDehum.RegenFanOutNode = fan->outletNodeNum;
             }
 
-            desicDehum.RegenCoilType = Alphas(9);
+            desicDehum.regenCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(9)));
             desicDehum.RegenCoilName = Alphas(10);
-            RegenCoilType = Alphas(9);
-            RegenCoilName = Alphas(10);
             desicDehum.RegenSetPointTemp = Numbers(1);
 
-            if (!lAlphaBlanks(10)) {
-                if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Electric") ||
-                    Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Fuel")) {
-                    if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Electric"))
-                        desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingElectric;
-                    if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Fuel"))
-                        desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingGasOrOtherFuel;
-                    ErrorsFound2 = false;
-                    ValidateComponent(state, RegenCoilType, RegenCoilName, ErrorsFound2, desicDehum.DehumType + " \"" + desicDehum.Name + "\"");
-                    if (ErrorsFound2) ErrorsFoundGeneric = true;
-
-                    if (desicDehum.RegenSetPointTemp <= 0.0) {
-                        ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                        ShowContinueError(state, format("{} must be greater than 0.", cNumericFields(1)));
-                        ErrorsFoundGeneric = true;
-                    }
-
-                    ErrorsFound2 = false;
-                    desicDehum.RegenCoilInletNode = HeatingCoils::GetCoilInletNode(state, RegenCoilType, RegenCoilName, ErrorsFound2);
-                    if (ErrorsFound2) {
-                        ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                        ErrorsFoundGeneric = true;
-                    }
-
-                    ErrorsFound2 = false;
-                    desicDehum.RegenCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, RegenCoilType, RegenCoilName, ErrorsFound2);
-                    if (ErrorsFound2) {
-                        ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                        ErrorsFoundGeneric = true;
-                    }
-
-                    ErrorsFound2 = false;
-                    HeatingCoils::GetCoilIndex(state, RegenCoilName, desicDehum.RegenCoilIndex, ErrorsFound2);
-                    if (ErrorsFound2) {
-                        ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                        ErrorsFoundGeneric = true;
-                    }
-
-                    ErrorsFound2 = false;
-                    RegenCoilControlNodeNum = HeatingCoils::GetCoilControlNodeNum(state, RegenCoilType, RegenCoilName, ErrorsFound2);
-                    if (ErrorsFound2) {
-                        ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                        ErrorsFoundGeneric = true;
-                    }
+            if (desicDehum.regenCoilType == HVAC::CoilType::HeatingElectric || 
+                desicDehum.regenCoilType == HVAC::CoilType::HeatingGasOrOtherFuel) {
+                if (desicDehum.RegenSetPointTemp <= 0.0) {
+                    ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
+                    ShowContinueError(state, format("{} must be greater than 0.", cNumericFields(1)));
+                    ErrorsFoundGeneric = true;
+                }
 
-                    if (RegenCoilControlNodeNum > 0) {
+                desicDehum.RegenCoilNum = HeatingCoils::GetCoilIndex(state, desicDehum.RegenCoilName);
+                if (desicDehum.RegenCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(10), desicDehum.RegenCoilName);
+                    ErrorsFoundGeneric = true;
+                } else {
+                    desicDehum.RegenCoilInletNode = HeatingCoils::GetCoilAirInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.RegenCoilOutletNode = HeatingCoils::GetCoilAirOutletNode(state, desicDehum.RegenCoilNum);
+                    int RegenCoilControlNode = HeatingCoils::GetCoilControlNode(state, desicDehum.RegenCoilNum);
+                    if (RegenCoilControlNode > 0) {
                         ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                         ShowContinueError(state,
                                           format("{} is specified as {:.3R} C in this object.", cNumericFields(1), desicDehum.RegenSetPointTemp));
                         ShowContinueError(state, " Do not specify a coil temperature setpoint node name in the regeneration air heater object.");
-                        ShowContinueError(state, format("...{} = {}", cAlphaFields(9), desicDehum.RegenCoilType));
+                        ShowContinueError(state, format("...{} = {}", cAlphaFields(9), Alphas(9)));
                         ShowContinueError(state, format("...{} = {}", cAlphaFields(10), desicDehum.RegenCoilName));
                         ShowContinueError(
                             state, format("...heating coil temperature setpoint node = {}", state.dataLoopNodes->NodeID(RegenCoilControlNodeNum)));
@@ -858,144 +730,63 @@ namespace DesiccantDehumidifiers {
                         ErrorsFoundGeneric = true;
                     }
 
-                    RegairHeatingCoilFlag = true;
-                    HeatingCoils::SetHeatingCoilData(state, desicDehum.RegenCoilIndex, ErrorsFound2, RegairHeatingCoilFlag, DesicDehumNum);
+                    HeatingCoils::SetCoilDesicData(state, desicDehum.RegenCoilNum, true, DesicDehumNum);
+                }
+                
+            } else if (desicDehum.regenCoilType == HVAC::CoilType::HeatingWater) {
+                if (desicDehum.RegenSetPointTemp <= 0.0) {
+                    ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
+                    ShowContinueError(state, format("{} must be greater than 0.", cNumericFields(1)));
+                    ErrorsFoundGeneric = true;
+                }
+              
+                desicDehum.RegenCoilNum = WaterCoils::GetCoilIndex(state, desicDehum.RegenCoilName);
+                if (desicDehum.RegenCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(10), desicDehum.RegenCoilName);
+                    ErrorsFound = true;
+                } else {
+
+                    desicDehum.CoilControlNode = WaterCoils::GetCoilWaterInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, desicDehum.RegenCoilNum);
+                    desicDehum.RegenCoilInletNode = WaterCoils::GetCoilAirInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.RegenCoilOutletNode = WaterCoils::GetCoilAirOutletNode(state, desicDehum.RegenCoilNum);
+                    
+                    WaterCoils::SetWaterCoilData(state, desicDehum.RegenCoilNum, ErrorsFound2, true, DesicDehumNum);
                     if (ErrorsFound2) {
                         ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                         ErrorsFoundGeneric = true;
                     }
+                }
+                
+            } else if (desicDehum.regenCoilType == HVAC::CoilType::HeatingSteam) { 
+                if (desicDehum.RegenSetPointTemp <= 0.0) {
+                    ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
+                    ShowContinueError(state, format("{} must be greater than 0.", cNumericFields(1)));
+                    ErrorsFoundGeneric = true;
+                }
 
-                } else if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Water")) {
-                    desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingWater;
-                    ValidateComponent(state, RegenCoilType, RegenCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    } else { // mine data from heating coil object
-                        errFlag = false;
-                        desicDehum.RegenCoilIndex = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", RegenCoilName, errFlag);
-                        if (desicDehum.RegenCoilIndex == 0) {
-                            ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(9), RegenCoilName));
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        if (desicDehum.RegenSetPointTemp <= 0.0) {
-                            ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                            ShowContinueError(state, format("{} must be greater than 0.", cNumericFields(1)));
-                            ErrorsFoundGeneric = true;
-                        }
-
-                        // Get the Heating Coil Hot water Inlet or control Node number
-                        errFlag = false;
-                        desicDehum.CoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Regeneration Heating Coil hot water max volume flow rate
-                        errFlag = false;
-                        desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Regeneration Heating Coil Inlet Node
-                        errFlag = false;
-                        int RegenCoilAirInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                        desicDehum.RegenCoilInletNode = RegenCoilAirInletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Regeneration Heating Coil Outlet Node
-                        errFlag = false;
-                        int RegenCoilAirOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", RegenCoilName, errFlag);
-                        desicDehum.RegenCoilOutletNode = RegenCoilAirOutletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        RegairHeatingCoilFlag = true;
-                        WaterCoils::SetWaterCoilData(state, desicDehum.RegenCoilIndex, ErrorsFound2, RegairHeatingCoilFlag, DesicDehumNum);
-                        if (ErrorsFound2) {
-                            ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                            ErrorsFoundGeneric = true;
-                        }
-                    }
-                } else if (Util::SameString(desicDehum.RegenCoilType, "Coil:Heating:Steam")) {
-                    desicDehum.RegenCoilType_Num = HVAC::Coil_HeatingSteam;
-                    ValidateComponent(state, RegenCoilType, RegenCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    } else { // mine data from the regeneration heating coil object
-                        if (desicDehum.RegenSetPointTemp <= 0.0) {
-                            ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                            ShowContinueError(state, format("{} must be greater than 0.", cNumericFields(1)));
-                            ErrorsFoundGeneric = true;
-                        }
-
-                        errFlag = false;
-                        desicDehum.RegenCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", RegenCoilName, errFlag);
-                        if (desicDehum.RegenCoilIndex == 0) {
-                            ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(9), RegenCoilName));
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the regeneration Heating Coil steam inlet node number
-                        errFlag = false;
-                        desicDehum.CoilControlNode = SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", RegenCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the regeneration heating Coil steam max volume flow rate
-                        desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilIndex, errFlag);
-                        if (desicDehum.MaxCoilFluidFlow > 0.0) {
-                            Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, dehumidifierDesiccantNoFans);
-                            desicDehum.MaxCoilFluidFlow *= SteamDensity;
-                        }
-
-                        // Get the regeneration heating Coil Inlet Node
-                        errFlag = false;
-                        int RegenCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, desicDehum.RegenCoilIndex, RegenCoilName, errFlag);
-                        desicDehum.RegenCoilInletNode = RegenCoilAirInletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the regeneration heating Coil Outlet Node
-                        errFlag = false;
-                        int RegenCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, desicDehum.RegenCoilIndex, RegenCoilName, errFlag);
-                        desicDehum.RegenCoilOutletNode = RegenCoilAirOutletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, desicDehum.Name));
-                            ErrorsFound = true;
-                        }
+                desicDehum.RegenCoilNum = SteamCoils::GetCoilIndex(state, RegenCoilName);
+                if (desicDehum.RegenCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), desicDehum.RegenCoilName);
+                    ErrorsFound = true;
+                } else {
+                    desicDehum.CoilControlNode = SteamCoils::GetCoilSteamInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilNum);
+                    if (desicDehum.MaxCoilFluidFlow > 0.0) {
+                        Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, dehumidifierDesiccantNoFans);
+                        desicDehum.MaxCoilFluidFlow *= SteamDensity;
                     }
 
-                    ErrorsFound2 = false;
-                    RegenCoilControlNodeNum = SteamCoils::GetSteamCoilControlNodeNum(state, RegenCoilType, RegenCoilName, ErrorsFound2);
+                    desicDehum.RegenCoilInletNode = SteamCoils::GetCoilAirInletNode(state, desicDehum.RegenCoilNum);
+                    desicDehum.RegenCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, desicDehum.RegenCoilNum);
+                    int RegenCoilControlNode = SteamCoils::GetCoilControlNode(state, desicDehum.RegenCoilNum);
 
-                    if (ErrorsFound2) {
-                        ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                        ErrorsFoundGeneric = true;
-                    }
-
-                    if (RegenCoilControlNodeNum > 0) {
+                    if (RegenCoilControlNode > 0) {
                         ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                         ShowContinueError(state,
                                           format("{} is specified as {:.3R} C in this object.", cNumericFields(1), desicDehum.RegenSetPointTemp));
                         ShowContinueError(state, " Do not specify a coil temperature setpoint node name in the regeneration air heater object.");
-                        ShowContinueError(state, format("...{} = {}", cAlphaFields(9), desicDehum.RegenCoilType));
+                        ShowContinueError(state, format("...{} = {}", cAlphaFields(9), Alphas(9)));
                         ShowContinueError(state, format("...{} = {}", cAlphaFields(10), desicDehum.RegenCoilName));
                         ShowContinueError(
                             state, format("...heating coil temperature setpoint node = {}", state.dataLoopNodes->NodeID(RegenCoilControlNodeNum)));
@@ -1003,36 +794,30 @@ namespace DesiccantDehumidifiers {
                         ErrorsFoundGeneric = true;
                     }
 
-                    RegairHeatingCoilFlag = true;
-                    SteamCoils::SetSteamCoilData(state, desicDehum.RegenCoilIndex, ErrorsFound2, RegairHeatingCoilFlag, DesicDehumNum);
+                    SteamCoils::SetSteamCoilData(state, desicDehum.RegenCoilNum, ErrorsFound2, true, DesicDehumNum);
                     if (ErrorsFound2) {
                         ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                         ErrorsFoundGeneric = true;
                     }
-
-                } else {
-                    ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                    ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(9), desicDehum.RegenCoilType));
-                    ErrorsFoundGeneric = true;
                 }
+                
+            } else {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(9), Alphas(9));
+                ErrorsFoundGeneric = true;
             }
 
             std::string RegenAirInlet = state.dataLoopNodes->NodeID(desicDehum.HXRegenInNode);
-
             std::string RegenAirOutlet = state.dataLoopNodes->NodeID(desicDehum.HXRegenOutNode);
-
             std::string RegenFanInlet = state.dataLoopNodes->NodeID(desicDehum.RegenFanInNode);
-
             std::string RegenFanOutlet = state.dataLoopNodes->NodeID(desicDehum.RegenFanOutNode);
 
             if (!lAlphaBlanks(10)) {
                 RegenCoilInlet = state.dataLoopNodes->NodeID(desicDehum.RegenCoilInletNode);
-
                 RegenCoilOutlet = state.dataLoopNodes->NodeID(desicDehum.RegenCoilOutletNode);
             }
 
             BranchNodeConnections::SetUpCompSets(
-                state, desicDehum.DehumType, desicDehum.Name, desicDehum.HXType, desicDehum.HXName, ProcAirInlet, ProcAirOutlet);
+                 state, desicDehum.DehumType, desicDehum.Name, HVAC::hxTypeNames[(int)desicDehum.hxType], desicDehum.hxName, ProcAirInlet, ProcAirOutlet);
 
             BranchNodeConnections::SetUpCompSets(state,
                                                  desicDehum.DehumType,
@@ -1046,7 +831,7 @@ namespace DesiccantDehumidifiers {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      desicDehum.DehumType,
                                                      desicDehum.Name,
-                                                     desicDehum.RegenCoilType,
+                                                     HVAC::coilTypeNames[(int)desicDehum.regenCoilType],
                                                      desicDehum.RegenCoilName,
                                                      RegenCoilInlet,
                                                      RegenCoilOutlet);
@@ -1154,99 +939,53 @@ namespace DesiccantDehumidifiers {
                 }
             }
 
-            desicDehum.CoolingCoilType = Alphas(11);
-            desicDehum.CoolingCoilName = Alphas(12);
+            desicDehum.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(11)));
+            desicDehum.CoolCoilName = Alphas(12);
 
-            if (!lAlphaBlanks(12)) {
-                if ((Util::SameString(desicDehum.CoolingCoilType, "COIL:COOLING:DX:SINGLESPEED")) ||
-                    (Util::SameString(desicDehum.CoolingCoilType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) ||
-                    (Util::SameString(desicDehum.CoolingCoilType, "COIL:COOLING:DX:VARIABLESPEED"))) {
-                    ErrorsFound2 = false;
-                    ValidateComponent(state,
-                                      desicDehum.CoolingCoilType,
-                                      desicDehum.CoolingCoilName,
-                                      ErrorsFound2,
-                                      desicDehum.DehumType + " \"" + desicDehum.Name + "\"");
-                    if (ErrorsFound2) ErrorsFoundGeneric = true;
-
-                    if ((Util::SameString(desicDehum.CoolingCoilType, "COIL:COOLING:DX:SINGLESPEED"))) {
-                        desicDehum.coolingCoil_TypeNum = HVAC::CoilDX_CoolingSingleSpeed;
-                    } else if ((Util::SameString(desicDehum.CoolingCoilType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE"))) {
-                        desicDehum.coolingCoil_TypeNum = HVAC::CoilDX_CoolingTwoStageWHumControl;
-                    } else if ((Util::SameString(desicDehum.CoolingCoilType, "COIL:COOLING:DX:VARIABLESPEED"))) {
-                        desicDehum.coolingCoil_TypeNum = HVAC::Coil_CoolingAirToAirVariableSpeed;
-                    }
+            if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed || 
+                desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
 
-                } else {
-                    ShowSevereError(state, format("{}={}", desicDehum.DehumType, desicDehum.Name));
-                    ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(11), desicDehum.CoolingCoilType));
-                    ErrorsFoundGeneric = true;
+                desicDehum.CoolingCoilIndex = DXCoils::GetCoilIndex(state, desicDehum.CoolCoilName);
+                if (desicDehum.CoolingCoilIndex == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(12), desicDehum.CoolCoilName);
+                    ErrorsFound = true;
+                } else { 
+                    desicDehum.CoolingCoilOutletNode = DXCoils::GetCoilAirOutletNode(state, desicDehum.CoolingCoilIndex);
+                    desicDehum.CompanionCoilCapacity = DXCoils::GetCoilCapacity(state, desicDehum.CoolingCoilIndex);
                 }
-
-                if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                    (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                    ErrorsFound2 = false;
-                    desicDehum.CoolingCoilOutletNode =
-                        DXCoils::GetCoilOutletNode(state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                    desicDehum.CompanionCoilCapacity =
-                        DXCoils::GetCoilCapacity(state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                    if (ErrorsFound2) ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.CoolingCoilName));
-
-                    ErrorsFound2 = false;
-                    DXCoils::GetDXCoilIndex(state, desicDehum.CoolingCoilName, desicDehum.DXCoilIndex, ErrorsFound2, desicDehum.CoolingCoilType);
-                    if (ErrorsFound2) ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.CoolingCoilName));
-                } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    ErrorsFound2 = false;
-                    desicDehum.CoolingCoilOutletNode = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(
-                        state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                    ErrorsFound2 = false;
-                    desicDehum.CompanionCoilCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                    if (ErrorsFound2) ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.CoolingCoilName));
-                    ErrorsFound2 = false;
-                    desicDehum.DXCoilIndex =
-                        VariableSpeedCoils::GetCoilIndexVariableSpeed(state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                    if (ErrorsFound2) ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.CoolingCoilName));
+                
+            } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                desicDehum.CoolingCoilIndex = VariableSpeedCoils::GetCoilIndex(state, desicDehum.CoolCoilName);
+                if (desicDehum.CoolingCoilIndex == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(12), desicDehum.CoolCoilName);
+                    ErrorsFound = true;
+                } else {
+                    desicDehum.CoolingCoilOutletNode = VariableSpeedCoils::GetCoilAirOutletNode(state, desicDehum.CoolingCoilIndex);
+                    desicDehum.CompanionCoilCapacity = VariableSpeedCoils::GetCoilCapacity(state, desicDehum.CoolingCoilIndex);
                 }
 
             } //  (desicDehum%CoolingCoilName /= Blank)THEN
 
-            if (Util::SameString(Alphas(13), "Yes")) {
-                desicDehum.CoilUpstreamOfProcessSide = Selection::Yes;
-            } else if (lAlphaBlanks(13)) {
-                desicDehum.CoilUpstreamOfProcessSide = Selection::No;
-            } else if (Util::SameString(Alphas(13), "No")) {
-                desicDehum.CoilUpstreamOfProcessSide = Selection::No;
+            if (lAlphaBlanks(13)) {
+                desicDehum.CoilUpstreamOfProcessSide = false;
+            } else if (BooleanSwitch bs = getYesNoValue(Alphas(13)); bs != BooleanSwitch::Invalid) {
+                desicDehum.CoilUpstreamOfProcessSide = static_cast<bool>(bs);
             } else {
-                ShowWarningError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                ShowContinueError(state, format("Invalid choice for {} = {}", cAlphaFields(13), Alphas(13)));
-                ShowContinueError(state, "...resetting to the default value of No");
-                desicDehum.CoilUpstreamOfProcessSide = Selection::No;
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(13), Alphas(13));
+                ErrorsFound = true;
             }
 
-            if (Util::SameString(Alphas(14), "Yes")) {
-                desicDehum.Preheat = Selection::Yes;
-            } else if (Util::SameString(Alphas(14), "No")) {
-                desicDehum.Preheat = Selection::No;
-            } else if (lAlphaBlanks(14)) {
-                desicDehum.Preheat = Selection::No;
+            if (lAlphaBlanks(14)) {
+                desicDehum.Preheat = false;
+            } else if (BooleanSwitch bs = getYesNoValue(Alphas(14)); bs != BooleanSwitch::Invalid) {
+                desicDehum.Preheat = static_cast<bool>(bs);
             } else {
-                ShowWarningError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                ShowContinueError(state, format("Invalid choice for {} = {}", cAlphaFields(14), Alphas(14)));
-                ShowContinueError(state, "...resetting to the default value of NO");
-                desicDehum.Preheat = Selection::No;
+                ShowSevereInvalidBool(state, eoh, cAlphaFields(14), Alphas(14));
             }
 
-            if (desicDehum.DXCoilIndex > 0) {
-
-                if (desicDehum.Preheat == Selection::Yes) { // Companion coil waste heat used for regeneration of desiccant
-                    ErrorsFound2 = false;
-                    DesuperHeaterIndex =
-                        HeatingCoils::GetHeatReclaimSourceIndex(state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                    if (ErrorsFound2) {
-                        ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
-                        ErrorsFoundGeneric = true;
-                    }
+            if (desicDehum.CoolingCoilIndex > 0) {
+                if (desicDehum.Preheat) { // Companion coil waste heat used for regeneration of desiccant
+                    DesuperHeaterIndex = HeatingCoils::GetCoilHeatReclaimSourceIndex(state, desicDehum.CoolingCoilIndex);
 
                     if (DesuperHeaterIndex > 0) {
                         ShowWarningError(state, format("{}={}", desicDehum.DehumType, desicDehum.Name));
@@ -1255,24 +994,23 @@ namespace DesiccantDehumidifiers {
                                           "desiccant regeneration.");
                         ShowContinueError(state,
                                           format("A Coil:Heating:Desuperheater object was found using waste heat from the {} \"{}\" object.",
-                                                 desicDehum.CoolingCoilType,
-                                                 desicDehum.CoolingCoilName));
+                                                 HVAC::coilTypeNames[(int)desicDehum.coolCoilType],
+                                                 desicDehum.CoolCoilName));
                         //          ErrorsFoundGeneric = .TRUE.
                     }
                 }
-                if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                    (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                    ErrorsFound2 = false;
-                    desicDehum.CondenserInletNode =
-                        DXCoils::GetCoilCondenserInletNode(state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    ErrorsFound2 = false;
-                    desicDehum.CondenserInletNode = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, desicDehum.CoolingCoilName, ErrorsFound2);
+
+                if ((desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) ||
+                    (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl)) {
+                    desicDehum.CondenserInletNode = DXCoils::GetCoilCondenserInletNode(state, desicDehum.CoolingCoilIndex);
+                } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                    desicDehum.CondenserInletNode = VariableSpeedCoils::GetCoilCondenserInletNode(state, desicDehum.CoolingCoilIndex);
                 }
-                if (desicDehum.CondenserInletNode == 0 && desicDehum.Preheat == Selection::Yes) {
+                
+                if (desicDehum.CondenserInletNode == 0 && desicDehum.Preheat) {
                     desicDehum.CondenserInletNode =
                         NodeInputManager::GetOnlySingleNode(state,
-                                                            desicDehum.CoolingCoilName + " Condenser Inlet Node",
+                                                            desicDehum.CoolCoilName + " Condenser Inlet Node",
                                                             ErrorsFound,
                                                             DataLoopNode::ConnectionObjectType::DehumidifierDesiccantSystem,
                                                             desicDehum.Name,
@@ -1288,12 +1026,13 @@ namespace DesiccantDehumidifiers {
                                                  "companion cooling coil.",
                                                  cAlphaFields(14)));
                         ShowContinueError(
-                            state, format("Adding condenser inlet air node for {} \"{}\"", desicDehum.CoolingCoilType, desicDehum.CoolingCoilName));
+                                          state, format("Adding condenser inlet air node for {} \"{}\"", HVAC::coilTypeNames[(int)desicDehum.coolCoilType], desicDehum.CoolCoilName));
                         ShowContinueError(
                             state, format("...condenser inlet air node name = {}", state.dataLoopNodes->NodeID(desicDehum.CondenserInletNode)));
                         ShowContinueError(state, "...this node name will be specified as an outdoor air node.");
                     }
-                } else if (desicDehum.Preheat == Selection::Yes) {
+
+                } else if (desicDehum.Preheat) {
                     if (!OutAirNodeManager::CheckOutAirNodeNumber(state, desicDehum.CondenserInletNode)) {
                         ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                         ShowContinueError(
@@ -1309,26 +1048,23 @@ namespace DesiccantDehumidifiers {
                 desicDehum.RegenInletIsOutsideAirNode = true;
             }
 
-            if (desicDehum.DXCoilIndex == 0 && desicDehum.Preheat == Selection::Yes) {
+            if (desicDehum.CoolingCoilIndex == 0 && desicDehum.Preheat) {
                 ShowWarningError(state, format("{}={}", desicDehum.DehumType, desicDehum.Name));
                 ShowContinueError(
                     state, format("A valid {} must be used when condenser waste heat is reclaimed for desiccant regeneration.", cAlphaFields(12)));
-                ShowContinueError(state, format("... {} = {}", cAlphaFields(11), desicDehum.CoolingCoilType));
-                ShowContinueError(state, format("... {} = {}", cAlphaFields(12), desicDehum.CoolingCoilName));
+                ShowContinueError(state, format("... {} = {}", cAlphaFields(11), HVAC::coilTypeNames[(int)desicDehum.coolCoilType]));
+                ShowContinueError(state, format("... {} = {}", cAlphaFields(12), desicDehum.CoolCoilName));
                 ErrorsFoundGeneric = true;
             }
 
-            if (desicDehum.DXCoilIndex > 0 && desicDehum.CoilUpstreamOfProcessSide == Selection::Yes) {
-                if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                    (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                    ErrorsFound2 = false;
-                    CoilBypassedFlowFrac =
-                        DXCoils::GetDXCoilBypassedFlowFrac(state, desicDehum.CoolingCoilType, desicDehum.CoolingCoilName, ErrorsFound2);
-                } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    ErrorsFound2 = false;
+            if (desicDehum.CoolingCoilIndex > 0 && desicDehum.CoilUpstreamOfProcessSide) {
+                if ((desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) ||
+                    (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl)) {
+                    CoilBypassedFlowFrac = DXCoils::GetCoilBypassedFlowFrac(state, desicDehum.CoolingCoilIndex);
+                } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     CoilBypassedFlowFrac = 0.0; // bypass flow fraction not in VS coil model
                 }
-                if (ErrorsFound2) ShowContinueError(state, format("...occurs in {} \"{}\"", desicDehum.DehumType, desicDehum.CoolingCoilName));
+
                 if (CoilBypassedFlowFrac > 0.0) {
                     ShowWarningError(state, format("{}={}", desicDehum.DehumType, desicDehum.Name));
                     ShowContinueError(
@@ -1339,17 +1075,17 @@ namespace DesiccantDehumidifiers {
                                       format("A DX coil with a bypassed air flow fraction greater than 0 may be upstream of the process inlet "
                                              "however the input for {} must be specified as No.",
                                              cAlphaFields(13)));
-                    ShowContinueError(state, format("... {} = {}", cAlphaFields(11), desicDehum.CoolingCoilType));
-                    ShowContinueError(state, format("... {} = {}", cAlphaFields(12), desicDehum.CoolingCoilName));
+                    ShowContinueError(state, format("... {} = {}", cAlphaFields(11), HVAC::coilTypeNames[(int)desicDehum.coolCoilType]));
+                    ShowContinueError(state, format("... {} = {}", cAlphaFields(12), desicDehum.CoolCoilName));
                     ErrorsFoundGeneric = true;
                 }
-            } else if (desicDehum.DXCoilIndex == 0 && desicDehum.CoilUpstreamOfProcessSide == Selection::Yes) {
+            } else if (desicDehum.CoolingCoilIndex == 0 && desicDehum.CoilUpstreamOfProcessSide) {
                 ShowSevereError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                 ShowContinueError(state, format("A valid companion coil must be specified when {} is specified as Yes.", cAlphaFields(13)));
                 ErrorsFoundGeneric = true;
             }
 
-            if (!desicDehum.RegenInletIsOutsideAirNode && desicDehum.Preheat == Selection::Yes) {
+            if (!desicDehum.RegenInletIsOutsideAirNode && desicDehum.Preheat) {
                 ShowWarningError(state, format("{}={}", desicDehum.DehumType, desicDehum.Name));
                 ShowContinueError(
                     state,
@@ -1361,15 +1097,15 @@ namespace DesiccantDehumidifiers {
                 ErrorsFoundGeneric = true;
             }
 
-            if (desicDehum.CoilUpstreamOfProcessSide == Selection::Yes) {
+            if (desicDehum.CoilUpstreamOfProcessSide) {
                 if (desicDehum.ProcAirInNode != desicDehum.CoolingCoilOutletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                     ShowContinueError(state, "Node names are inconsistent in companion cooling coil and desiccant heat exchanger objects.");
                     ShowContinueError(state,
-                                      format("For companion cooling coil = {} \"{}\"", desicDehum.CoolingCoilType, desicDehum.CoolingCoilName));
+                                      format("For companion cooling coil = {} \"{}\"", HVAC::coilTypeNames[(int)desicDehum.coolCoilType], desicDehum.CoolCoilName));
                     ShowContinueError(
                         state, format("The outlet node name in cooling coil = {}", state.dataLoopNodes->NodeID(desicDehum.CoolingCoilOutletNode)));
-                    ShowContinueError(state, format("For desiccant heat exchanger = {} \"{}\"", desicDehum.HXType, desicDehum.HXName));
+                    ShowContinueError(state, format("For desiccant heat exchanger = {} \"{}\"", HVAC::hxTypeNames[(int)desicDehum.hxType], desicDehum.hxName));
                     ShowContinueError(state, format("The process air inlet node name = {}", state.dataLoopNodes->NodeID(desicDehum.ProcAirInNode)));
                     ShowFatalError(state, "...previous error causes program termination.");
                 }
@@ -1390,7 +1126,7 @@ namespace DesiccantDehumidifiers {
                                                                         cAlphaFields(15));               // Field Name
             }
 
-            if (desicDehum.Preheat == Selection::Yes) {
+            if (desicDehum.Preheat) {
                 ErrorsFound2 = false;
                 if (desicDehum.ExhaustFanMaxVolFlowRate <= 0) {
                     ErrorsFound2 = true;
@@ -1403,7 +1139,7 @@ namespace DesiccantDehumidifiers {
                     ShowContinueError(
                         state, format("{} and {} must be defined if {} field is \"Yes\".", cNumericFields(2), cNumericFields(3), cAlphaFields(14)));
                 }
-            } else if (desicDehum.Preheat == Selection::No) {
+            } else if (desicDehum.Preheat) {
                 if (desicDehum.ExhaustFanMaxVolFlowRate > 0.0) {
                     ShowWarningError(state, format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                     ShowContinueError(state, format("{} should be 0 if {} field is \"No\".", cNumericFields(2), cAlphaFields(14)));
@@ -1607,8 +1343,9 @@ namespace DesiccantDehumidifiers {
         }
 
         if (state.dataDesiccantDehumidifiers->MyPlantScanFlag(DesicDehumNum) && allocated(state.dataPlnt->PlantLoop)) {
-            if ((desicDehum.RegenCoilType_Num == HVAC::Coil_HeatingWater) || (desicDehum.RegenCoilType_Num == HVAC::Coil_HeatingSteam)) {
-                if (desicDehum.RegenCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (desicDehum.regenCoilType == HVAC::CoilType::HeatingWater ||
+                desicDehum.regenCoilType == HVAC::CoilType::HeatingSteam) {
+                if (desicDehum.regenCoilType == HVAC::CoilType::HeatingWater) {
                     ErrorFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(state,
                                                             desicDehum.RegenCoilName,
@@ -1625,15 +1362,14 @@ namespace DesiccantDehumidifiers {
                     }
 
                     ErrorFlag = false;
-                    desicDehum.MaxCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", desicDehum.RegenCoilName, ErrorFlag);
+                    desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, desicDehum.RegenCoilNum);
                     if (desicDehum.MaxCoilFluidFlow > 0.0) {
                         Real64 FluidDensity =
                             state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, initCBVAV);
                         desicDehum.MaxCoilFluidFlow *= FluidDensity;
                     }
 
-                } else if (desicDehum.RegenCoilType_Num == HVAC::Coil_HeatingSteam) {
+                } else if (desicDehum.regenCoilType == HVAC::CoilType::HeatingSteam) {
 
                     ErrorFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(state,
@@ -1651,7 +1387,7 @@ namespace DesiccantDehumidifiers {
                         ShowFatalError(state, "InitDesiccantDehumidifier: Program terminated for previous conditions.");
                     }
                     ErrorFlag = false;
-                    desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilIndex, ErrorFlag);
+                    desicDehum.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilNum);
 
                     if (desicDehum.MaxCoilFluidFlow > 0.0) {
                         Real64 FluidDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
@@ -1730,11 +1466,10 @@ namespace DesiccantDehumidifiers {
                 if (desicDehum.CoilControlNode > 0) {
                     //    If water coil max water flow rate is autosized, simulate once in order to mine max water flow rate
                     if (desicDehum.MaxCoilFluidFlow == DataSizing::AutoSize) {
-                        if (desicDehum.RegenCoilType_Num == HVAC::Coil_HeatingWater) {
-                            WaterCoils::SimulateWaterCoilComponents(state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilIndex);
+                        if (desicDehum.regenCoilType == HVAC::CoilType::HeatingWater) {
+                            WaterCoils::SimulateWaterCoilComponents(state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilNum);
                             ErrorFlag = false;
-                            Real64 CoilMaxVolFlowRate =
-                                WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", desicDehum.RegenCoilName, ErrorFlag);
+                            Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, desicDehum.RegenCoilNum);
                             // if (ErrorFlag) {
                             //    ErrorsFound = true;
                             //}
@@ -1744,15 +1479,15 @@ namespace DesiccantDehumidifiers {
                                 desicDehum.MaxCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity;
                             }
                         }
-                        if (desicDehum.RegenCoilType_Num == HVAC::Coil_HeatingSteam) {
+                        if (desicDehum.regenCoilType == HVAC::CoilType::HeatingSteam) {
                             SteamCoils::SimulateSteamCoilComponents(state,
                                                                     desicDehum.RegenCoilName,
                                                                     FirstHVACIteration,
-                                                                    desicDehum.RegenCoilIndex,
+                                                                    desicDehum.RegenCoilNum,
                                                                     1.0,
                                                                     QCoilActual); // simulate any load > 0 to get max capacity of steam coil
                             ErrorFlag = false;
-                            Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilIndex, ErrorFlag);
+                            Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, desicDehum.RegenCoilNum);
                             // if (ErrorFlag) {
                             //    ErrorsFound = true;
                             //}
@@ -2285,7 +2020,7 @@ namespace DesiccantDehumidifiers {
                 desicDehum.RegenCapErrorIndex1);
             ShowRecurringContinueErrorAtEnd(state, desicDehum.DehumType + '=' + desicDehum.Name, desicDehum.RegenCapErrorIndex2);
             ShowRecurringContinueErrorAtEnd(state,
-                                            format("Load requested [W] from {} = {}", desicDehum.RegenCoilType, desicDehum.RegenCoilName),
+                                            format("Load requested [W] from {} = {}", HVAC::coilTypeNames[(int)desicDehum.regenCoilType], desicDehum.RegenCoilName),
                                             desicDehum.RegenCapErrorIndex3,
                                             QRegen);
             ShowRecurringContinueErrorAtEnd(state, "Load request exceeded delivered by [W]", desicDehum.RegenCapErrorIndex4, (QRegen - QDelivered));
@@ -2359,7 +2094,7 @@ namespace DesiccantDehumidifiers {
 
         UnitOn = false;
         DDPartLoadRatio = 0.0;
-        RegenCoilIndex = desicDehum.RegenCoilIndex;
+        RegenCoilIndex = desicDehum.RegenCoilNum;
         FanDeltaT = 0.0;
         RegenSetPointTemp = desicDehum.RegenSetPointTemp;
         ExhaustFanMassFlowRate = 0.0;
@@ -2368,10 +2103,10 @@ namespace DesiccantDehumidifiers {
         OnOffFanPLF = state.dataHVACGlobal->OnOffFanPartLoadFraction;
         state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
 
-        if (desicDehum.CoilUpstreamOfProcessSide == Selection::Yes) {
+        if (desicDehum.CoilUpstreamOfProcessSide) {
             // Cooling coil directly upstream of desiccant dehumidifier, dehumidifier runs in tandem with DX coil
 
-            CompanionCoilIndexNum = desicDehum.DXCoilIndex;
+            CompanionCoilIndexNum = desicDehum.CoolingCoilIndex;
         } else {
             // desiccant dehumidifier determines its own PLR
             CompanionCoilIndexNum = 0;
@@ -2381,10 +2116,10 @@ namespace DesiccantDehumidifiers {
             UnitOn = true;
         }
 
-        if (desicDehum.CoilUpstreamOfProcessSide == Selection::Yes) {
-            if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                if (state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.DXCoilIndex) == 0.0) {
+        if (desicDehum.CoilUpstreamOfProcessSide) {
+            if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                if (state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.CoolingCoilIndex) == 0.0) {
                     UnitOn = false;
                 }
             }
@@ -2393,7 +2128,7 @@ namespace DesiccantDehumidifiers {
         if (UnitOn) {
 
             if (desicDehum.RegenInletIsOutsideAirNode) {
-                if (desicDehum.HXTypeNum == BalancedHX) {
+                if (desicDehum.hxType == HVAC::HXType::Desiccant_Balanced) {
                     state.dataLoopNodes->Node(desicDehum.RegenAirInNode).MassFlowRate =
                         state.dataLoopNodes->Node(desicDehum.ProcAirInNode).MassFlowRate;
                     state.dataLoopNodes->Node(desicDehum.RegenAirInNode).MassFlowRateMaxAvail =
@@ -2402,16 +2137,16 @@ namespace DesiccantDehumidifiers {
             }
 
             // Get conditions from DX Coil condenser if present (DXCoilIndex verified > 0 in GetInput)
-            if (desicDehum.Preheat == Selection::Yes) {
+            if (desicDehum.Preheat) {
 
                 //     condenser waste heat is proportional to DX coil PLR
-                if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                    (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                    CondenserWasteHeat = state.dataHeatBal->HeatReclaimDXCoil(desicDehum.DXCoilIndex).AvailCapacity;
-                    state.dataHeatBal->HeatReclaimDXCoil(desicDehum.DXCoilIndex).AvailCapacity = 0.0;
-                } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    CondenserWasteHeat = state.dataHeatBal->HeatReclaimVS_Coil(desicDehum.DXCoilIndex).AvailCapacity;
-                    state.dataHeatBal->HeatReclaimVS_Coil(desicDehum.DXCoilIndex).AvailCapacity = 0.0;
+                if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                    desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    CondenserWasteHeat = state.dataHeatBal->HeatReclaimDXCoil(desicDehum.CoolingCoilIndex).AvailCapacity;
+                    state.dataHeatBal->HeatReclaimDXCoil(desicDehum.CoolingCoilIndex).AvailCapacity = 0.0;
+                } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                    CondenserWasteHeat = state.dataHeatBal->HeatReclaimVS_Coil(desicDehum.CoolingCoilIndex).AvailCapacity;
+                    state.dataHeatBal->HeatReclaimVS_Coil(desicDehum.CoolingCoilIndex).AvailCapacity = 0.0;
                 }
 
                 CpAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(desicDehum.CondenserInletNode).HumRat);
@@ -2428,10 +2163,10 @@ namespace DesiccantDehumidifiers {
                 if (CompanionCoilIndexNum > 0) {
 
                     //     calculate PLR and actual condenser outlet node (regen inlet node) temperature
-                    if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                        (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                        DDPartLoadRatio = state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.DXCoilIndex);
-                        if (state.dataDXCoils->DXCoilFanOp(desicDehum.DXCoilIndex) == HVAC::FanOp::Continuous) {
+                    if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                        desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                        DDPartLoadRatio = state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.CoolingCoilIndex);
+                        if (state.dataDXCoils->DXCoilFanOp(desicDehum.CoolingCoilIndex) == HVAC::FanOp::Continuous) {
                             NewRegenInTemp =
                                 state.dataLoopNodes->Node(desicDehum.CondenserInletNode).Temp +
                                 CondenserWasteHeat / (CpAir * (state.dataLoopNodes->Node(desicDehum.RegenAirInNode).MassFlowRate) * DDPartLoadRatio);
@@ -2440,7 +2175,7 @@ namespace DesiccantDehumidifiers {
                             NewRegenInTemp = state.dataLoopNodes->Node(desicDehum.CondenserInletNode).Temp +
                                              CondenserWasteHeat / (CpAir * (state.dataLoopNodes->Node(desicDehum.RegenAirInNode).MassFlowRate));
                         }
-                    } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                    } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                         DDPartLoadRatio = 1.0; // condenser waste heat already includes modulation down
                         NewRegenInTemp = state.dataLoopNodes->Node(desicDehum.CondenserInletNode).Temp +
                                          CondenserWasteHeat / (CpAir * (state.dataLoopNodes->Node(desicDehum.RegenAirInNode).MassFlowRate));
@@ -2515,9 +2250,9 @@ namespace DesiccantDehumidifiers {
                     }
 
                     HeatRecovery::SimHeatRecovery(state,
-                                                  desicDehum.HXName,
+                                                  desicDehum.hxName,
                                                   FirstHVACIteration,
-                                                  desicDehum.CompIndex,
+                                                  desicDehum.hxNum,
                                                   HVAC::FanOp::Continuous,
                                                   1.0,
                                                   true,
@@ -2525,7 +2260,7 @@ namespace DesiccantDehumidifiers {
                                                   desicDehum.RegenInletIsOutsideAirNode,
                                                   _,
                                                   _,
-                                                  desicDehum.coolingCoil_TypeNum);
+                                                  desicDehum.coolCoilType);
 
                     //       calculate desiccant part-load ratio
                     if (state.dataLoopNodes->Node(desicDehum.ProcAirInNode).HumRat != state.dataLoopNodes->Node(desicDehum.ProcAirOutNode).HumRat) {
@@ -2593,9 +2328,9 @@ namespace DesiccantDehumidifiers {
                     //       CompanionCoilIndexNum .EQ. 0 means the same thing as desicDehum%CoilUpstreamOfProcessSide == No
                     if (CompanionCoilIndexNum == 0) {
                         HeatRecovery::SimHeatRecovery(state,
-                                                      desicDehum.HXName,
+                                                      desicDehum.hxName,
                                                       FirstHVACIteration,
-                                                      desicDehum.CompIndex,
+                                                      desicDehum.hxNum,
                                                       HVAC::FanOp::Continuous,
                                                       1.0,
                                                       true,
@@ -2603,7 +2338,7 @@ namespace DesiccantDehumidifiers {
                                                       desicDehum.RegenInletIsOutsideAirNode,
                                                       _,
                                                       _,
-                                                      desicDehum.coolingCoil_TypeNum);
+                                                      desicDehum.coolCoilType);
 
                         //         calculate desiccant part-load ratio
                         if (state.dataLoopNodes->Node(desicDehum.ProcAirInNode).HumRat !=
@@ -2616,10 +2351,10 @@ namespace DesiccantDehumidifiers {
                             DDPartLoadRatio = 1.0;
                         }
                     } else {
-                        if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                            (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                            DDPartLoadRatio = state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.DXCoilIndex);
-                        } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                        if ((desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) ||
+                            (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl)) {
+                            DDPartLoadRatio = state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.CoolingCoilIndex);
+                        } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                             DDPartLoadRatio = 1.0; // condenser waste heat already includes modulation down
                         }
                     }
@@ -2664,9 +2399,9 @@ namespace DesiccantDehumidifiers {
             }
 
             HeatRecovery::SimHeatRecovery(state,
-                                          desicDehum.HXName,
+                                          desicDehum.hxName,
                                           FirstHVACIteration,
-                                          desicDehum.CompIndex,
+                                          desicDehum.hxNum,
                                           HVAC::FanOp::Continuous,
                                           DDPartLoadRatio,
                                           true,
@@ -2674,7 +2409,7 @@ namespace DesiccantDehumidifiers {
                                           desicDehum.RegenInletIsOutsideAirNode,
                                           _,
                                           _,
-                                          desicDehum.coolingCoil_TypeNum);
+                                          desicDehum.coolCoilType);
 
             if (desicDehum.regenFanPlace == HVAC::FanPlace::DrawThru) {
                 state.dataFans->fans(desicDehum.RegenFanIndex)->simulate(state, FirstHVACIteration, _, _);
@@ -2686,13 +2421,13 @@ namespace DesiccantDehumidifiers {
                 (state.dataLoopNodes->Node(desicDehum.ProcAirInNode).HumRat - state.dataLoopNodes->Node(desicDehum.ProcAirOutNode).HumRat);
 
             // If preheat is Yes, exhaust fan is condenser fan, if CoilUpstreamOfProcessSide is No, DD runs an its own PLR
-            if (desicDehum.Preheat == Selection::Yes && desicDehum.CoilUpstreamOfProcessSide == Selection::No) {
+            if (desicDehum.Preheat && !desicDehum.CoilUpstreamOfProcessSide) {
                 //    should actually use DX coil RTF instead of PLR since fan power is being calculated
-                if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                    (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
+                if ((desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) ||
+                    (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl)) {
                     desicDehum.ExhaustFanPower += max(
-                        0.0, (desicDehum.ExhaustFanMaxPower * (state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.DXCoilIndex) - DDPartLoadRatio)));
-                } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                        0.0, (desicDehum.ExhaustFanMaxPower * (state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.CoolingCoilIndex) - DDPartLoadRatio)));
+                } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     desicDehum.ExhaustFanPower += max(0.0, (desicDehum.ExhaustFanMaxPower * (1.0 - DDPartLoadRatio)));
                 }
             }
@@ -2715,9 +2450,9 @@ namespace DesiccantDehumidifiers {
             }
 
             HeatRecovery::SimHeatRecovery(state,
-                                          desicDehum.HXName,
+                                          desicDehum.hxName,
                                           FirstHVACIteration,
-                                          desicDehum.CompIndex,
+                                          desicDehum.hxNum,
                                           HVAC::FanOp::Continuous,
                                           0.0,
                                           false,
@@ -2725,7 +2460,7 @@ namespace DesiccantDehumidifiers {
                                           desicDehum.RegenInletIsOutsideAirNode,
                                           _,
                                           _,
-                                          desicDehum.coolingCoil_TypeNum);
+                                          desicDehum.coolCoilType);
 
             if (desicDehum.regenFanPlace == HVAC::FanPlace::DrawThru) {
                 state.dataFans->fans(desicDehum.RegenFanIndex)->simulate(state, FirstHVACIteration, _, _);
@@ -2733,11 +2468,11 @@ namespace DesiccantDehumidifiers {
 
             // Turn on exhaust fan if DX Coil is operating
             if (desicDehum.ExhaustFanMaxVolFlowRate > 0) {
-                if (desicDehum.DXCoilIndex > 0) {
-                    if ((desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingSingleSpeed) ||
-                        (desicDehum.coolingCoil_TypeNum == HVAC::CoilDX_CoolingTwoStageWHumControl)) {
-                        DDPartLoadRatio = state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.DXCoilIndex);
-                    } else if (desicDehum.coolingCoil_TypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (desicDehum.CoolingCoilIndex > 0) {
+                    if ((desicDehum.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) ||
+                        (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl)) {
+                        DDPartLoadRatio = state.dataDXCoils->DXCoilPartLoadRatio(desicDehum.CoolingCoilIndex);
+                    } else if (desicDehum.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                         DDPartLoadRatio = 1.0; // condenser waste heat already includes modulation down
                     }
                     desicDehum.ExhaustFanPower = desicDehum.ExhaustFanMaxPower * DDPartLoadRatio;
@@ -2904,20 +2639,20 @@ namespace DesiccantDehumidifiers {
 
         RegenCoilActual = 0.0;
         if (RegenCoilLoad > HVAC::SmallLoad) {
-            switch (desicDehum.RegenCoilType_Num) {
-            case HVAC::Coil_HeatingGasOrOtherFuel:
-            case HVAC::Coil_HeatingElectric: {
+            switch (desicDehum.regenCoilType) {
+            case HVAC::CoilType::HeatingGasOrOtherFuel:
+            case HVAC::CoilType::HeatingElectric: {
                 HeatingCoils::SimulateHeatingCoilComponents(
-                    state, desicDehum.RegenCoilName, FirstHVACIteration, RegenCoilLoad, desicDehum.RegenCoilIndex, RegenCoilActual);
+                    state, desicDehum.RegenCoilName, FirstHVACIteration, RegenCoilLoad, desicDehum.RegenCoilNum, RegenCoilActual);
             } break;
-            case HVAC::Coil_HeatingWater: {
+            case HVAC::CoilType::HeatingWater: {
                 MaxHotWaterFlow = desicDehum.MaxCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
                     state, MaxHotWaterFlow, desicDehum.CoilControlNode, desicDehum.CoilOutletNode, desicDehum.plantLoc);
                 RegenCoilActual = RegenCoilLoad;
                 // simulate the regenerator hot water heating coil
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilIndex, RegenCoilActual);
+                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilNum, RegenCoilActual);
 
                 if (RegenCoilActual > (RegenCoilLoad + HVAC::SmallLoad)) {
                     // control water flow to obtain output matching RegenCoilLoad
@@ -2937,7 +2672,7 @@ namespace DesiccantDehumidifiers {
                         WaterCoils::SimulateWaterCoilComponents(state,
                                                                 state.dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).RegenCoilName,
                                                                 FirstHVACIteration,
-                                                                state.dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).RegenCoilIndex,
+                                                                state.dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).RegenCoilNum,
                                                                 RegenCoilActual);
                         if (RegenCoilHeatLoad != 0.0) {
                             return (RegenCoilActual - RegenCoilHeatLoad) / RegenCoilHeatLoad;
@@ -2987,40 +2722,42 @@ namespace DesiccantDehumidifiers {
                     RegenCoilActual = RegenCoilLoad;
                     // simulate the regenerator hot water heating coil
                     WaterCoils::SimulateWaterCoilComponents(
-                        state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilIndex, RegenCoilActual);
+                        state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilNum, RegenCoilActual);
                 }
             } break;
-            case HVAC::Coil_HeatingSteam: {
+              
+            case HVAC::CoilType::HeatingSteam: {
                 mdot = desicDehum.MaxCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(state, mdot, desicDehum.CoilControlNode, desicDehum.CoilOutletNode, desicDehum.plantLoc);
                 // simulate the regenerator steam heating coil
                 SteamCoils::SimulateSteamCoilComponents(
-                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilIndex, RegenCoilLoad, RegenCoilActual);
+                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilNum, RegenCoilLoad, RegenCoilActual);
             } break;
             default:
                 break;
             }
         } else {
-            switch (desicDehum.RegenCoilType_Num) {
-            case HVAC::Coil_HeatingGasOrOtherFuel:
-            case HVAC::Coil_HeatingElectric: {
+            switch (desicDehum.regenCoilType) {
+            case HVAC::CoilType::HeatingGasOrOtherFuel:
+            case HVAC::CoilType::HeatingElectric: {
                 HeatingCoils::SimulateHeatingCoilComponents(
-                    state, desicDehum.RegenCoilName, FirstHVACIteration, RegenCoilLoad, desicDehum.RegenCoilIndex, RegenCoilActual);
+                    state, desicDehum.RegenCoilName, FirstHVACIteration, RegenCoilLoad, desicDehum.RegenCoilNum, RegenCoilActual);
             } break;
-            case HVAC::Coil_HeatingWater: {
+            case HVAC::CoilType::HeatingWater: {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(state, mdot, desicDehum.CoilControlNode, desicDehum.CoilOutletNode, desicDehum.plantLoc);
                 RegenCoilActual = RegenCoilLoad;
                 // simulate the regenerator hot water heating coil
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilIndex, RegenCoilActual);
+                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilNum, RegenCoilActual);
             } break;
-            case HVAC::Coil_HeatingSteam: {
+              
+            case HVAC::CoilType::HeatingSteam: {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(state, mdot, desicDehum.CoilControlNode, desicDehum.CoilOutletNode, desicDehum.plantLoc);
                 // simulate the regenerator steam heating coil
                 SteamCoils::SimulateSteamCoilComponents(
-                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilIndex, RegenCoilLoad, RegenCoilActual);
+                    state, desicDehum.RegenCoilName, FirstHVACIteration, desicDehum.RegenCoilNum, RegenCoilLoad, RegenCoilActual);
             } break;
             default:
                 break;
diff --git a/src/EnergyPlus/DesiccantDehumidifiers.hh b/src/EnergyPlus/DesiccantDehumidifiers.hh
index dde2884968f..4645b2de5a5 100644
--- a/src/EnergyPlus/DesiccantDehumidifiers.hh
+++ b/src/EnergyPlus/DesiccantDehumidifiers.hh
@@ -82,14 +82,6 @@ namespace DesiccantDehumidifiers {
         Num
     };
 
-    enum class Selection
-    {
-        Invalid = -1,
-        No,  // Condenser waste heat NOT reclaimed for desiccant regeneration
-        Yes, // Condenser waste heat reclaimed for desiccant regeneration
-        Num
-    };
-
     enum class PerformanceModel
     {
         Invalid = -1,
@@ -98,17 +90,16 @@ namespace DesiccantDehumidifiers {
         Num
     };
 
-    //  Desiccant heat exchanger type
-    int constexpr BalancedHX(1); // HeatExchanger:Desiccant:BalancedFlow = 1
-
     struct DesiccantDehumidifierData
     {
         // Members
         // User Input data
         std::string Name;                      // unique name of component
         std::string Sched;                     // name of availability schedule
-        std::string RegenCoilType;             // type of regen coil
+        HVAC::CoilType regenCoilType = HVAC::CoilType::Invalid; 
         std::string RegenCoilName;             // name of regen coil
+        int RegenCoilNum = 0;             // Index for regen coil
+      
         std::string RegenFanName;              // name of regen fan
         PerformanceModel PerformanceModel_Num; // type of performance model, default or user curves
         int ProcAirInNode;                     // process air inlet node of dehumidifier
@@ -122,7 +113,6 @@ namespace DesiccantDehumidifiers {
         Real64 NomProcAirVolFlow;       // nominal process air flow rate [m3/s]
         Real64 NomProcAirVel;           // nominal process air velocity [m/s]
         Real64 NomRotorPower;           // rotor power consumption at full output [W]
-        int RegenCoilIndex;             // Index for regen coil
         int RegenFanIndex;              // Index for regen fan
         HVAC::FanType regenFanType;     // Fan type number (see DataHVACGlobals)
         int ProcDryBulbCurvefTW;        // number of process leaving dry bulb f(edb,ew) curve
@@ -175,14 +165,14 @@ namespace DesiccantDehumidifiers {
         int RegenFanErrorIndex3;               // recurring error message index for incorrect regen fan flow
         int RegenFanErrorIndex4;               // recurring error message index for incorrect regen fan flow
         // structure elements unique to generic desiccant dehumidifier
-        std::string HXType;                  // type of desiccant heat exchanger
-        std::string HXName;                  // name of desiccant heat exchanger
-        int HXTypeNum;                       // parameter number of desiccant heat exchanger
+        HVAC::HXType hxType = HVAC::HXType::Invalid;                  // type of desiccant heat exchanger
+        std::string hxName;                  // name of desiccant heat exchanger
+        int hxNum = 0;
+      
         std::string ExhaustFanCurveObject;   // exhaust fan curve object
-        std::string CoolingCoilType;         // type of cooling coil used with desiccant heat exchanger
-        std::string CoolingCoilName;         // name of cooling coil used with desiccant heat exchanger
-        int coolingCoil_TypeNum;             // type of cooling coil, DataHVACGlobals coil type constants
-        Selection Preheat;                   // determine condenser waste heat usage for pre heating regen air
+        std::string CoolCoilName;         // name of cooling coil used with desiccant heat exchanger
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;         // type of cooling coil, DataHVACGlobals coil type constants
+        bool Preheat = false;                   // determine condenser waste heat usage for pre heating regen air
         Real64 RegenSetPointTemp;            // heating set-point for regeneration air [C]
         Real64 ExhaustFanMaxVolFlowRate;     // exhaust fan maximum allowable air flow rate [m3/s]
         Real64 ExhaustFanMaxMassFlowRate;    // exhaust fan maximum allowable air mass flow rate [kg/s]
@@ -193,22 +183,21 @@ namespace DesiccantDehumidifiers {
         HVAC::FanPlace regenFanPlace;        // placement of the fan used for regeneration air flow
         int ControlNodeNum;                  // node number of control node
         int ExhaustFanCurveIndex;            // exhaust fan curve object index
-        int CompIndex;                       // index of HX component to call simheatrecovery
         int CoolingCoilOutletNode;           // node number of cooling coil outlet node
         int RegenFanOutNode;                 // fan outlet node number mined from regen fan object
         int RegenCoilInletNode;              // regen heating coil inlet node number mined from regen heater object
         int RegenCoilOutletNode;             // regen heating coil outlet node number mined from regen heater object
+        int RegenCoilControlNode;
         int HXProcInNode;                    // process inlet node num mined from desiccant heat exchanger object
         int HXProcOutNode;                   // process outlet node num mined from desiccant heat exchanger object
         int HXRegenInNode;                   // regen inlet node number mined from desiccant heat exchanger object
         int HXRegenOutNode;                  // regen outlet node number mined from desiccant heat exchanger object
         int CondenserInletNode;              // regen outlet node number mined from desiccant heat exchanger object
-        int DXCoilIndex;                     // DX Coil index mined from coil object
+        int CoolingCoilIndex;                // DX Coil index mined from coil object
         int ErrCount;                        // error count
         int ErrIndex1;                       // error index
-        Selection CoilUpstreamOfProcessSide; // used to determine if process inlet is pre-cooled
+        bool CoilUpstreamOfProcessSide = false; // used to determine if process inlet is pre-cooled
         bool RegenInletIsOutsideAirNode;     // regen inlet is connected to an outside air node
-        int RegenCoilType_Num;               // type number of regen coil
         int CoilControlNode;                 // heating coil hot water or steam inlet node
         int CoilOutletNode;                  // outlet node for water coil
         PlantLocation plantLoc;              // plant loop component location for water heating coil
@@ -221,7 +210,7 @@ namespace DesiccantDehumidifiers {
         DesiccantDehumidifierData()
             : PerformanceModel_Num(PerformanceModel::Invalid), ProcAirInNode(0), ProcAirOutNode(0), RegenAirInNode(0), RegenAirOutNode(0),
               RegenFanInNode(0), controlType(DesicDehumCtrlType::Invalid), HumRatSet(0.0), NomProcAirVolFlow(0.0), NomProcAirVel(0.0),
-              NomRotorPower(0.0), RegenCoilIndex(0), RegenFanIndex(0), regenFanType(HVAC::FanType::Invalid), ProcDryBulbCurvefTW(0),
+              NomRotorPower(0.0), RegenFanIndex(0), regenFanType(HVAC::FanType::Invalid), ProcDryBulbCurvefTW(0),
               ProcDryBulbCurvefV(0), ProcHumRatCurvefTW(0), ProcHumRatCurvefV(0), RegenEnergyCurvefTW(0), RegenEnergyCurvefV(0), RegenVelCurvefTW(0),
               RegenVelCurvefV(0), NomRegenTemp(121.0), MinProcAirInTemp(-73.3), MaxProcAirInTemp(65.6), MinProcAirInHumRat(0.0),
               MaxProcAirInHumRat(0.21273), NomProcAirMassFlow(0.0), NomRegenAirMassFlow(0.0), ProcAirInTemp(0.0), ProcAirInHumRat(0.0),
@@ -230,12 +219,12 @@ namespace DesiccantDehumidifiers {
               RegenAirVel(0.0), DehumTypeCode(DesicDehumType::Invalid), WaterRemove(0.0), WaterRemoveRate(0.0), SpecRegenEnergy(0.0), QRegen(0.0),
               RegenEnergy(0.0), ElecUseEnergy(0.0), ElecUseRate(0.0), PartLoad(0.0), RegenCapErrorIndex1(0), RegenCapErrorIndex2(0),
               RegenCapErrorIndex3(0), RegenCapErrorIndex4(0), RegenFanErrorIndex1(0), RegenFanErrorIndex2(0), RegenFanErrorIndex3(0),
-              RegenFanErrorIndex4(0), HXTypeNum(0), coolingCoil_TypeNum(0), Preheat(Selection::Invalid), RegenSetPointTemp(0.0),
+              RegenFanErrorIndex4(0), RegenSetPointTemp(0.0),
               ExhaustFanMaxVolFlowRate(0.0), ExhaustFanMaxMassFlowRate(0.0), ExhaustFanMaxPower(0.0), ExhaustFanPower(0.0),
               ExhaustFanElecConsumption(0.0), CompanionCoilCapacity(0.0), regenFanPlace(HVAC::FanPlace::Invalid), ControlNodeNum(0),
-              ExhaustFanCurveIndex(0), CompIndex(0), CoolingCoilOutletNode(0), RegenFanOutNode(0), RegenCoilInletNode(0), RegenCoilOutletNode(0),
-              HXProcInNode(0), HXProcOutNode(0), HXRegenInNode(0), HXRegenOutNode(0), CondenserInletNode(0), DXCoilIndex(0), ErrCount(0),
-              ErrIndex1(0), CoilUpstreamOfProcessSide(Selection::Invalid), RegenInletIsOutsideAirNode(false), RegenCoilType_Num(0),
+              ExhaustFanCurveIndex(0), CoolingCoilOutletNode(0), RegenFanOutNode(0), RegenCoilInletNode(0), RegenCoilOutletNode(0),
+              HXProcInNode(0), HXProcOutNode(0), HXRegenInNode(0), HXRegenOutNode(0), CondenserInletNode(0), CoolingCoilIndex(0), ErrCount(0),
+              ErrIndex1(0), RegenInletIsOutsideAirNode(false), 
               CoilControlNode(0), CoilOutletNode(0), HotWaterCoilMaxIterIndex(0), HotWaterCoilMaxIterIndex2(0), MaxCoilFluidFlow(0.0),
               RegenCoilCapacity(0.0)
         {
diff --git a/src/EnergyPlus/FanCoilUnits.cc b/src/EnergyPlus/FanCoilUnits.cc
index 51780208eb2..1591d9311e7 100644
--- a/src/EnergyPlus/FanCoilUnits.cc
+++ b/src/EnergyPlus/FanCoilUnits.cc
@@ -358,129 +358,100 @@ namespace FanCoilUnits {
                 }
             }
 
-            fanCoil.CCoilName = Alphas(12);
+            fanCoil.CoolCoilName = Alphas(12);
             fanCoil.MaxColdWaterVolFlow = Numbers(5);
             fanCoil.MinColdWaterVolFlow = Numbers(6);
             fanCoil.ColdControlOffset = Numbers(7);
-            fanCoil.HCoilName = Alphas(14);
-            fanCoil.HCoilType = Alphas(13);
+            fanCoil.HeatCoilName = Alphas(14);
+            
             fanCoil.MaxHotWaterVolFlow = Numbers(8);
             fanCoil.MinHotWaterVolFlow = Numbers(9);
             fanCoil.HotControlOffset = Numbers(10);
 
-            if (Util::SameString(Alphas(11), "Coil:Cooling:Water") || Util::SameString(Alphas(11), "Coil:Cooling:Water:DetailedGeometry") ||
-                Util::SameString(Alphas(11), "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
-                fanCoil.CCoilType = Alphas(11);
-                if (Util::SameString(Alphas(11), "Coil:Cooling:Water")) {
-                    fanCoil.CCoilType_Num = CCoil::Water;
-                    fanCoil.CCoilPlantName = fanCoil.CCoilName;
-                    fanCoil.CCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                }
-                if (Util::SameString(Alphas(11), "Coil:Cooling:Water:DetailedGeometry")) {
-                    fanCoil.CCoilType_Num = CCoil::Detailed;
-                    fanCoil.CCoilPlantName = fanCoil.CCoilName;
-                    fanCoil.CCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+            fanCoil.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(11)));
+            if (fanCoil.coolCoilType == HVAC::CoilType::Invalid) {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(11), Alphas(11));
+                ErrorsFound = true;
+                
+            } else if (fanCoil.coolCoilType == HVAC::CoilType::CoolingWater ||
+                       fanCoil.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
+                fanCoil.CoolCoilPlantType = fanCoil.coolCoilType == HVAC::CoilType::CoolingWater ?
+                    DataPlant::PlantEquipmentType::CoilWaterCooling :
+                    DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+
+                fanCoil.CoolCoilNum = WaterCoils::GetCoilIndex(state, fanCoil.CoolCoilName);
+                if (fanCoil.CoolCoilNum == 0) { 
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(12), fanCoil.CoolCoilName);
+                    ErrorsFound = true;
+                } else {
+                    auto &waterCoil = state.dataWaterCoils->WaterCoil(fanCoil.CoolCoilNum);
+                    fanCoil.CoolCoilFluidInletNode = waterCoil.WaterInletNodeNum;
+                    fanCoil.CoolCoilAirInletNode = waterCoil.AirInletNodeNum;
+                    fanCoil.CoolCoilAirOutletNode = waterCoil.AirOutletNodeNum;
                 }
-                std::string CCoilType;
-                if (Util::SameString(Alphas(11), "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
-                    fanCoil.CCoilType_Num = CCoil::HXAssist;
-                    HVACHXAssistedCoolingCoil::GetHXCoilTypeAndName(
-                        state, fanCoil.CCoilType, fanCoil.CCoilName, ErrorsFound, CCoilType, fanCoil.CCoilPlantName);
-                    if (Util::SameString(CCoilType, "Coil:Cooling:Water")) {
-                        fanCoil.CCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                    } else if (Util::SameString(CCoilType, "Coil:Cooling:Water:DetailedGeometry")) {
-                        fanCoil.CCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+                
+            } else if (fanCoil.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) { 
+                fanCoil.CoolCoilNum = HXAssistCoil::GetCoilIndex(state, fanCoil.CoolCoilName);
+                if (fanCoil.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(12), fanCoil.CoolCoilName);
+                    ErrorsFound = true;
+                } else {
+                    fanCoil.childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, fanCoil.CoolCoilNum);
+                    fanCoil.childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, fanCoil.CoolCoilNum);
+                    fanCoil.childCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(state, fanCoil.CoolCoilNum);
+                    if (fanCoil.coolCoilType == HVAC::CoilType::CoolingWater) {
+                        fanCoil.CoolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+                    } else if (fanCoil.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
+                        fanCoil.CoolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
                     } else {
                         ShowSevereError(state, format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, fanCoil.Name));
                         ShowContinueError(state, format("For: {}=\"{}\".", cAlphaFields(11), Alphas(11)));
-                        ShowContinueError(state, format("Invalid Coil Type={}, Name={}", CCoilType, fanCoil.CCoilPlantName));
+                        ShowContinueError(state, format("Invalid Coil Type={}, Name={}", HVAC::coilTypeNames[(int)fanCoil.childCoolCoilType], fanCoil.childCoolCoilName));
                         ShowContinueError(state, "must be \"Coil:Cooling:Water\" or \"Coil:Cooling:Water:DetailedGeometry\"");
                         ErrorsFound = true;
                     }
+
+                    // mine the cold water node from the coil object
+                    auto &waterCoil = state.dataWaterCoils->WaterCoil(fanCoil.childCoolCoilNum);
+                    fanCoil.CoolCoilFluidInletNode = waterCoil.WaterInletNodeNum;
+                    fanCoil.CoolCoilAirInletNode = waterCoil.AirInletNodeNum;
+                    fanCoil.CoolCoilAirOutletNode = waterCoil.AirOutletNodeNum;
                 }
-                IsNotOK = false;
-                ValidateComponent(state, fanCoil.CCoilType, fanCoil.CCoilName, IsNotOK, fanCoil.UnitType);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, fanCoil.Name));
-                    ErrorsFound = true;
-                } else {
-                    if (fanCoil.CCoilType_Num != CCoil::HXAssist) {
-                        // mine the cold water node from the coil object
-                        int coilIndex = WaterCoils::GetWaterCoilIndex(state, fanCoil.CCoilType, fanCoil.CCoilName, IsNotOK);
-                        // Other error checks should trap before it gets to this point in the code, but including just in case.
-                        if (IsNotOK) {
-                            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, fanCoil.Name));
-                            ErrorsFound = true;
-                        } else {
-                            fanCoil.CoolCoilFluidInletNode = state.dataWaterCoils->WaterCoil(coilIndex).WaterInletNodeNum;
-                            fanCoil.CoolCoilInletNodeNum = state.dataWaterCoils->WaterCoil(coilIndex).AirInletNodeNum;
-                            fanCoil.CoolCoilOutletNodeNum = state.dataWaterCoils->WaterCoil(coilIndex).AirOutletNodeNum;
-                        }
-                    } else {
-                        // mine the cold water node from the coil object
-                        int coilIndex = WaterCoils::GetWaterCoilIndex(state, CCoilType, fanCoil.CCoilPlantName, IsNotOK);
-                        // Other error checks should trap before it gets to this point in the code, but including just in case.
-                        if (IsNotOK) {
-                            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, fanCoil.Name));
-                            ErrorsFound = true;
-                        } else {
-                            fanCoil.CoolCoilFluidInletNode = state.dataWaterCoils->WaterCoil(coilIndex).WaterInletNodeNum;
-                            fanCoil.CoolCoilInletNodeNum = state.dataWaterCoils->WaterCoil(coilIndex).AirInletNodeNum;
-                            fanCoil.CoolCoilOutletNodeNum = state.dataWaterCoils->WaterCoil(coilIndex).AirOutletNodeNum;
-                        }
-                    }
-                }
-            } else {
-                ShowSevereError(state, format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, fanCoil.Name));
-                ShowContinueError(state, format("illegal value: {}=\"{}\".", cAlphaFields(11), Alphas(11)));
+            } 
+
+            fanCoil.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(13)));
+            if (fanCoil.coolCoilType == HVAC::CoilType::Invalid) {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(13), Alphas(13));
                 ErrorsFound = true;
-            }
 
-            if (Util::SameString(Alphas(13), "Coil:Heating:Water")) {
-                fanCoil.HCoilType_Num = HCoil::Water;
-                fanCoil.HCoilPlantTypeOf = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-                IsNotOK = false;
-                ValidateComponent(state, fanCoil.HCoilType, fanCoil.HCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, fanCoil.Name));
+            } else if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
+                fanCoil.HeatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+
+                // mine the hot water node from the coil object
+                fanCoil.HeatCoilNum = WaterCoils::GetCoilIndex(state, fanCoil.HeatCoilName);
+                if (fanCoil.HeatCoilNum == 0) { 
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(14), fanCoil.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    // mine the hot water node from the coil object
-                    int coilIndex = WaterCoils::GetWaterCoilIndex(state, fanCoil.HCoilType, fanCoil.HCoilName, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, fanCoil.Name));
-                        ErrorsFound = true;
-                    } else {
-                        fanCoil.HeatCoilFluidInletNode = state.dataWaterCoils->WaterCoil(coilIndex).WaterInletNodeNum;
-                        fanCoil.HeatCoilInletNodeNum = state.dataWaterCoils->WaterCoil(coilIndex).AirInletNodeNum;
-                        fanCoil.HeatCoilOutletNodeNum = state.dataWaterCoils->WaterCoil(coilIndex).AirOutletNodeNum;
-                    }
+                    auto &waterCoil = state.dataWaterCoils->WaterCoil(fanCoil.HeatCoilNum);
+                    fanCoil.HeatCoilFluidInletNode = waterCoil.WaterInletNodeNum;
+                    fanCoil.HeatCoilAirInletNode = waterCoil.AirInletNodeNum;
+                    fanCoil.HeatCoilAirOutletNode = waterCoil.AirOutletNodeNum;
                 }
-            } else if (Util::SameString(Alphas(13), "Coil:Heating:Electric")) {
-                fanCoil.HCoilType_Num = HCoil::Electric;
-                IsNotOK = false;
-                ValidateComponent(state, fanCoil.HCoilType, fanCoil.HCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, fanCoil.Name));
+
+            } else if (fanCoil.heatCoilType == HVAC::CoilType::HeatingElectric) { 
+                fanCoil.HeatCoilNum = HeatingCoils::GetCoilIndex(state, fanCoil.HeatCoilName);
+                if (fanCoil.HeatCoilNum == 0) {
+                  ShowSevereItemNotFound(state, eoh, cAlphaFields(14), fanCoil.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    int coilIndex;
-                    HeatingCoils::GetCoilIndex(state, fanCoil.HCoilName, coilIndex, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, fanCoil.Name));
-                        ErrorsFound = true;
-                    } else {
-                        fanCoil.DesignHeatingCapacity = state.dataHeatingCoils->HeatingCoil(coilIndex).NominalCapacity;
-                        fanCoil.HeatCoilInletNodeNum = state.dataHeatingCoils->HeatingCoil(coilIndex).AirInletNodeNum;
-                        fanCoil.HeatCoilOutletNodeNum = state.dataHeatingCoils->HeatingCoil(coilIndex).AirOutletNodeNum;
-                    }
+                    auto &waterCoil = state.dataHeatingCoils->HeatingCoil(fanCoil.HeatCoilNum);
+                    fanCoil.DesignHeatingCapacity = waterCoil.NominalCapacity;
+                    fanCoil.HeatCoilAirInletNode = waterCoil.AirInletNodeNum;
+                    fanCoil.HeatCoilAirOutletNode = waterCoil.AirOutletNodeNum;
                 }
-            } else {
-                ShowSevereError(state, format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, fanCoil.Name));
-                ShowContinueError(state, format("illegal value: {}=\"{}\".", cAlphaFields(13), Alphas(13)));
-                ErrorsFound = true;
             }
-
+            
             fanCoil.FanName = Alphas(10);
 
             if (!lAlphaBlanks(15)) {
@@ -506,9 +477,11 @@ namespace FanCoilUnits {
                                      Alphas(9),
                                      "Fan Type must be Fan:OnOff, Fan:ConstantVolume, Fan:VariableVolume, or Fan:SystemModel.");
                 ErrorsFound = true;
+
             } else if ((fanCoil.FanIndex = Fans::GetFanIndex(state, fanCoil.FanName)) == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(10), Alphas(10));
                 ErrorsFound = true;
+
             } else {
                 auto *fan = state.dataFans->fans(fanCoil.FanIndex);
 
@@ -811,14 +784,14 @@ namespace FanCoilUnits {
             }
             // Set up component set for cooling coil
             BranchNodeConnections::SetUpCompSets(
-                state, fanCoil.UnitType, fanCoil.Name, fanCoil.CCoilType, fanCoil.CCoilName, "UNDEFINED", "UNDEFINED");
+                state, fanCoil.UnitType, fanCoil.Name, HVAC::coilTypeNames[(int)fanCoil.coolCoilType], fanCoil.CoolCoilName, "UNDEFINED", "UNDEFINED");
 
             // Set up component set for heating coil
             BranchNodeConnections::SetUpCompSets(state,
                                                  fanCoil.UnitType,
                                                  fanCoil.Name,
-                                                 fanCoil.HCoilType,
-                                                 fanCoil.HCoilName,
+                                                 HVAC::coilTypeNames[(int)fanCoil.heatCoilType],
+                                                 fanCoil.HeatCoilName,
                                                  "UNDEFINED",
                                                  state.dataLoopNodes->NodeID(fanCoil.AirOutNode));
 
@@ -953,10 +926,10 @@ namespace FanCoilUnits {
                                 OutputProcessor::StoreType::Average,
                                 fanCoil.Name);
 
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-                state, fanCoil.CCoilName, fanCoil.CCoilType, fanCoil.FanName, fanCoil.fanType, fanCoil.FanIndex);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-                state, fanCoil.HCoilName, fanCoil.HCoilType, fanCoil.FanName, fanCoil.fanType, fanCoil.FanIndex);
+            ReportCoilSelection::setCoilSupplyFanInfo(
+                state, fanCoil.CoolCoilName, fanCoil.coolCoilType, fanCoil.FanName, fanCoil.fanType, fanCoil.FanIndex);
+            ReportCoilSelection::setCoilSupplyFanInfo(
+                state, fanCoil.HeatCoilName, fanCoil.heatCoilType, fanCoil.FanName, fanCoil.fanType, fanCoil.FanIndex);
         }
     }
 
@@ -1008,32 +981,32 @@ namespace FanCoilUnits {
 
         if (state.dataFanCoilUnits->MyPlantScanFlag(FanCoilNum) && allocated(state.dataPlnt->PlantLoop)) {
             bool errFlag = false;
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 PlantUtilities::ScanPlantLoopsForObject(
-                    state, fanCoil.HCoilName, fanCoil.HCoilPlantTypeOf, fanCoil.HeatCoilPlantLoc, errFlag, _, _, _, _, _);
+                    state, fanCoil.HeatCoilName, fanCoil.HeatCoilPlantType, fanCoil.HeatCoilPlantLoc, errFlag, _, _, _, _, _);
 
                 if (errFlag) {
                     ShowContinueError(state, format("Reference Unit=\"{}\", type={}", fanCoil.Name, fanCoil.UnitType));
                     ShowFatalError(state, "InitFanCoilUnits: Program terminated for previous conditions.");
                 }
 
-                fanCoil.HeatCoilFluidOutletNodeNum = DataPlant::CompData::getPlantComponent(state, fanCoil.HeatCoilPlantLoc).NodeNumOut;
+                fanCoil.HeatCoilFluidOutletNode = DataPlant::CompData::getPlantComponent(state, fanCoil.HeatCoilPlantLoc).NodeNumOut;
 
-            } else if (fanCoil.HCoilType_Num == HCoil::Electric) {
+            } else if (fanCoil.heatCoilType == HVAC::CoilType::HeatingElectric) {
                 // do nothing, valid type
             } else {
                 ShowFatalError(state, format("InitFanCoilUnits: FanCoil={}, invalid heating coil type. Program terminated.", fanCoil.Name));
             }
 
-            if ((fanCoil.CCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
-                (fanCoil.CCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) {
+            if ((fanCoil.CoolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
+                (fanCoil.CoolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) {
                 PlantUtilities::ScanPlantLoopsForObject(
-                    state, fanCoil.CCoilPlantName, fanCoil.CCoilPlantType, fanCoil.CoolCoilPlantLoc, errFlag, _, _, _, _, _);
+                    state, fanCoil.CoolCoilName, fanCoil.CoolCoilPlantType, fanCoil.CoolCoilPlantLoc, errFlag, _, _, _, _, _);
                 if (errFlag) {
                     ShowContinueError(state, format("Reference Unit=\"{}\", type={}", fanCoil.Name, fanCoil.UnitType));
                     ShowFatalError(state, "InitFanCoilUnits: Program terminated for previous conditions.");
                 }
-                fanCoil.CoolCoilFluidOutletNodeNum = DataPlant::CompData::getPlantComponent(state, fanCoil.CoolCoilPlantLoc).NodeNumOut;
+                fanCoil.CoolCoilFluidOutletNode = DataPlant::CompData::getPlantComponent(state, fanCoil.CoolCoilPlantLoc).NodeNumOut;
             } else {
                 ShowFatalError(state, format("InitFanCoilUnits: FanCoil={}, invalid cooling coil type. Program terminated.", fanCoil.Name));
             }
@@ -1070,7 +1043,7 @@ namespace FanCoilUnits {
             fanCoil.MaxAirMassFlow = RhoAir * fanCoil.MaxAirVolFlow;
             fanCoil.OutAirMassFlow = RhoAir * fanCoil.OutAirVolFlow;
 
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 Real64 rho =
                     state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
                 fanCoil.MaxHeatCoilFluidFlow = rho * fanCoil.MaxHotWaterVolFlow;
@@ -1082,13 +1055,13 @@ namespace FanCoilUnits {
             fanCoil.MinColdWaterFlow = rho * fanCoil.MinColdWaterVolFlow;
 
             // set the node max and min mass flow rates
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 PlantUtilities::InitComponentNodes(
-                    state, fanCoil.MinHotWaterFlow, fanCoil.MaxHeatCoilFluidFlow, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum);
+                    state, fanCoil.MinHotWaterFlow, fanCoil.MaxHeatCoilFluidFlow, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode);
             }
 
             PlantUtilities::InitComponentNodes(
-                state, fanCoil.MinColdWaterFlow, fanCoil.MaxCoolCoilFluidFlow, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum);
+                state, fanCoil.MinColdWaterFlow, fanCoil.MaxCoolCoilFluidFlow, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode);
 
             if (fanCoil.OutsideAirNode > 0) {
                 state.dataLoopNodes->Node(fanCoil.OutsideAirNode).MassFlowRateMax = fanCoil.OutAirMassFlow;
@@ -1166,8 +1139,6 @@ namespace FanCoilUnits {
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         Real64 DesCoilLoad; // coil load used for sizing [W]
-        std::string CoolingCoilName;
-        std::string CoolingCoilType;
         Real64 rho;
         Real64 Cp;
         int zoneHVACIndex;        // index of zoneHVAC equipment sizing specification
@@ -1490,7 +1461,7 @@ namespace FanCoilUnits {
             }
         }
 
-        if (fanCoil.HCoilType_Num == HCoil::Water) {
+        if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
             IsAutoSize = false;
             if (fanCoil.MaxHotWaterVolFlow == DataSizing::AutoSize) {
                 IsAutoSize = true;
@@ -1503,21 +1474,17 @@ namespace FanCoilUnits {
                             state, fanCoil.UnitType, fanCoil.Name, "User-Specified Maximum Hot Water Flow [m3/s]", fanCoil.MaxHotWaterVolFlow);
                     }
                 } else {
-                    state.dataFanCoilUnits->CoilWaterInletNode =
-                        WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", fanCoil.HCoilName, ErrorsFound);
-                    state.dataFanCoilUnits->CoilWaterOutletNode =
-                        WaterCoils::GetCoilWaterOutletNode(state, "Coil:Heating:Water", fanCoil.HCoilName, ErrorsFound);
                     if (IsAutoSize) {
                         int PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(state,
                                                                                "Coil:Heating:Water",
-                                                                               fanCoil.HCoilName,
-                                                                               state.dataFanCoilUnits->CoilWaterInletNode,
-                                                                               state.dataFanCoilUnits->CoilWaterOutletNode,
+                                                                               fanCoil.HeatCoilName,
+                                                                               fanCoil.HeatCoilFluidInletNode,
+                                                                               fanCoil.HeatCoilFluidOutletNode,
                                                                                ErrorsFound);
-                        CoilNum = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", fanCoil.HCoilName, ErrorsFound);
                         bool DoWaterCoilSizing; // if TRUE do water coil sizing calculation
-                        if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) {
-                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp;
+                        auto &waterCoil = state.dataWaterCoils->WaterCoil(fanCoil.HeatCoilNum);
+                        if (waterCoil.UseDesignWaterDeltaTemp) {
+                            WaterCoilSizDeltaT = waterCoil.DesignWaterDeltaTemp;
                             DoWaterCoilSizing = true;
                         } else {
                             if (PltSizHeatNum > 0) {
@@ -1648,10 +1615,10 @@ namespace FanCoilUnits {
                     }
                 }
             }
-        } else if (fanCoil.HCoilType_Num == HCoil::Electric) {
+        } else if (fanCoil.heatCoilType == HVAC::CoilType::HeatingElectric) {
             if (fanCoil.DesignHeatingCapacity == DataSizing::AutoSize) {
-                CompName = fanCoil.HCoilName;
-                CompType = fanCoil.HCoilType;
+                CompName = fanCoil.HeatCoilName;
+                CompType = HVAC::coilTypeNames[(int)fanCoil.heatCoilType];
                 SizingMethod = HVAC::HeatingCapacitySizing;
                 PrintFlag = false;
                 TempSize = fanCoil.DesignHeatingCapacity;
@@ -1676,27 +1643,18 @@ namespace FanCoilUnits {
                         state, fanCoil.UnitType, fanCoil.Name, "User-Specified Maximum Cold Water Flow [m3/s]", fanCoil.MaxColdWaterVolFlow);
                 }
             } else {
-                if (Util::SameString(fanCoil.CCoilType, "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
-                    CoolingCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, fanCoil.CCoilType, fanCoil.CCoilName, ErrorsFound);
-                    CoolingCoilType = HVACHXAssistedCoolingCoil::GetHXCoilType(state, fanCoil.CCoilType, fanCoil.CCoilName, ErrorsFound);
-                } else {
-                    CoolingCoilName = fanCoil.CCoilName;
-                    CoolingCoilType = fanCoil.CCoilType;
-                }
-                state.dataFanCoilUnits->CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
-                state.dataFanCoilUnits->CoilWaterOutletNode =
-                    WaterCoils::GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
                 if (IsAutoSize) {
                     int PltSizCoolNum = PlantUtilities::MyPlantSizingIndex(state,
-                                                                           CoolingCoilType,
-                                                                           CoolingCoilName,
-                                                                           state.dataFanCoilUnits->CoilWaterInletNode,
-                                                                           state.dataFanCoilUnits->CoilWaterOutletNode,
+                                                                           HVAC::coilTypeNames[(int)fanCoil.coolCoilType],
+                                                                           fanCoil.CoolCoilName,
+                                                                           fanCoil.CoolCoilFluidInletNode,
+                                                                           fanCoil.CoolCoilFluidOutletNode,
                                                                            ErrorsFound);
-                    CoilNum = WaterCoils::GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
+
                     bool DoWaterCoilSizing; // if TRUE do water coil sizing calculation
-                    if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) {
-                        WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp;
+                    auto &waterCoil = state.dataWaterCoils->WaterCoil(fanCoil.CoolCoilNum);
+                    if (waterCoil.UseDesignWaterDeltaTemp) {
+                        WaterCoilSizDeltaT = waterCoil.DesignWaterDeltaTemp;
                         DoWaterCoilSizing = true;
                     } else {
                         if (PltSizCoolNum > 0) {
@@ -1892,25 +1850,18 @@ namespace FanCoilUnits {
 
         } // if ( CurZoneEqNum > 0 )
 
-        // set the design air flow rates for the heating and cooling coils
-        if (Util::SameString(fanCoil.CCoilType, "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
-            CoolingCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, fanCoil.CCoilType, fanCoil.CCoilName, ErrorsFound);
-            CoolingCoilType = HVACHXAssistedCoolingCoil::GetHXCoilType(state, fanCoil.CCoilType, fanCoil.CCoilName, ErrorsFound);
-        } else {
-            CoolingCoilName = fanCoil.CCoilName;
-            CoolingCoilType = fanCoil.CCoilType;
-        }
         if (state.dataSize->ZoneSizingRunDone) {
-            WaterCoils::SetCoilDesFlow(
-                state, CoolingCoilType, CoolingCoilName, state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesCoolVolFlow, ErrorsFound);
             WaterCoils::SetCoilDesFlow(state,
-                                       fanCoil.HCoilType,
-                                       fanCoil.HCoilName,
-                                       state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatVolFlow,
-                                       ErrorsFound);
+                                       fanCoil.CoolCoilNum,
+                                       state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesCoolVolFlow);
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) { 
+                WaterCoils::SetCoilDesFlow(state, fanCoil.HeatCoilNum, state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatVolFlow);
+            }
         } else {
-            WaterCoils::SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, fanCoil.MaxAirVolFlow, ErrorsFound);
-            WaterCoils::SetCoilDesFlow(state, fanCoil.HCoilType, fanCoil.HCoilName, fanCoil.MaxAirVolFlow, ErrorsFound);
+            WaterCoils::SetCoilDesFlow(state, fanCoil.CoolCoilNum, fanCoil.MaxAirVolFlow);
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) { 
+                WaterCoils::SetCoilDesFlow(state, fanCoil.HeatCoilNum, fanCoil.MaxAirVolFlow);
+            }
         }
         if (state.dataSize->CurZoneEqNum > 0) {
             zoneEqSizing.MaxHWVolFlow = fanCoil.MaxHotWaterVolFlow;
@@ -2017,15 +1968,15 @@ namespace FanCoilUnits {
             // set water coil flow rate to 0 to calculate coil off capacity (only valid while flow is unlocked)
             mdot = 0.0;
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
             if (state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).LoopSide(fanCoil.CoolCoilPlantLoc.loopSideNum).FlowLock ==
                 DataPlant::FlowLock::Locked) {
                 ColdFlowLocked = true; // check for flow lock
             }
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                 if (state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).LoopSide(fanCoil.HeatCoilPlantLoc.loopSideNum).FlowLock ==
                     DataPlant::FlowLock::Locked) {
                     HotFlowLocked = true; // save locked flow
@@ -2060,7 +2011,7 @@ namespace FanCoilUnits {
                 // get full load result
                 mdot = MaxWaterFlow;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
                 Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOutMaxC);
                 if (!ColdFlowLocked) {
                     fanCoil.QUnitOutMaxC = QUnitOutMaxC;
@@ -2139,7 +2090,7 @@ namespace FanCoilUnits {
                 if (!ColdFlowLocked) {
                     mdot = CWFlow; // not flowlocked - set flow to CWFlow
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
                     Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut); // get QUnitOut
                 } else {
                     // flow lock on
@@ -2151,23 +2102,23 @@ namespace FanCoilUnits {
                                          QUnitOut); // get QUnitOut with CWFlow; rest will be bypassed
                         state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).MassFlowRate =
                             MdotLockC; // reset flow to locked value. Since lock is on, must do this by hand
-                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNodeNum).MassFlowRate = MdotLockC;
+                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNode).MassFlowRate = MdotLockC;
                         // Keep soln flow rate but reset outlet water temperature - i.e. bypass extra water
                         CWFlowBypass = MdotLockC - CWFlow;
                         // change water outlet temperature and enthalpy
-                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNodeNum).Temp =
+                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNode).Temp =
                             (CWFlowBypass * state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).Temp +
-                             CWFlow * state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNodeNum).Temp) /
+                             CWFlow * state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNode).Temp) /
                             MdotLockC;
-                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNodeNum).Enthalpy =
+                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNode).Enthalpy =
                             (CWFlowBypass * state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).Enthalpy +
-                             CWFlow * state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNodeNum).Enthalpy) /
+                             CWFlow * state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNode).Enthalpy) /
                             MdotLockC;
                     } else {
                         // if MdotLockC <= CWFlow use MdotLockC as is
                         state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).MassFlowRate =
                             MdotLockC; // reset flow to locked value. Since lock is on, must do this by hand
-                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNodeNum).MassFlowRate = MdotLockC;
+                        state.dataLoopNodes->Node(fanCoil.CoolCoilFluidOutletNode).MassFlowRate = MdotLockC;
                         Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut);
                     }
                 }
@@ -2180,7 +2131,7 @@ namespace FanCoilUnits {
             } else if (UnitOn && QCoilHeatSP > HVAC::SmallLoad &&
                        state.dataHeatBalFanSys->TempControlType(ControlledZoneNum) != HVAC::SetptType::SingleCool) {
                 // get full load result
-                if (fanCoil.HCoilType_Num == HCoil::Water) { // if HW Coil
+                if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) { // if HW Coil
                     int ControlNode = fanCoil.HeatCoilFluidInletNode;
                     ControlOffset = fanCoil.HotControlOffset;
                     MaxWaterFlow = fanCoil.MaxHeatCoilFluidFlow;
@@ -2193,7 +2144,7 @@ namespace FanCoilUnits {
                     }
                     mdot = MaxWaterFlow;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                     Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOutMaxH);
                     if (!HotFlowLocked) {
                         fanCoil.QUnitOutMaxH = QUnitOutMaxH;
@@ -2208,7 +2159,7 @@ namespace FanCoilUnits {
                 QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToHeatSP;
                 if (QUnitOutMaxH > QZnReq) {
                     // more heating than required, find reduced water flow rate to meet the load
-                    if (fanCoil.HCoilType_Num == HCoil::Water) {
+                    if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                         // solve for the hot water flow rate with no limit set by flow rate lockdown
                         auto f = [&state, FirstHVACIteration, FanCoilNum, ControlledZoneNum, QZnReq](Real64 HWFlow) {
                             // To calculate the part-load ratio for the FCU with electric heating coil
@@ -2287,17 +2238,17 @@ namespace FanCoilUnits {
                     }
                 } else {
                     // demand greater than capacity
-                    if (fanCoil.HCoilType_Num == HCoil::Water) {
+                    if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                         HWFlow = MaxWaterFlow;
                     } else {
                         Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut, 1.0);
                     }
                 }
-                if (fanCoil.HCoilType_Num == HCoil::Water) {
+                if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                     if (!HotFlowLocked) {
                         mdot = HWFlow; // not flowlocked - set flow to HWFlow
                         PlantUtilities::SetComponentFlowRate(
-                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                         Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut); // get QUnitOut
                     } else {
                         // flow lock on
@@ -2309,23 +2260,23 @@ namespace FanCoilUnits {
                                              QUnitOut); // get QUnitOut with HWFlow; rest will be bypassed
                             state.dataLoopNodes->Node(fanCoil.HeatCoilFluidInletNode).MassFlowRate =
                                 MdotLockH; // reset flow to locked value. Since lock is on, must do this by hand
-                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNodeNum).MassFlowRate = MdotLockH;
+                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNode).MassFlowRate = MdotLockH;
                             // Keep soln flow rate but reset outlet water temperature - i.e. bypass extra water
                             HWFlowBypass = MdotLockH - HWFlow;
                             // change outlet water temperature and enthalpy
-                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNodeNum).Temp =
+                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNode).Temp =
                                 (HWFlowBypass * state.dataLoopNodes->Node(fanCoil.HeatCoilFluidInletNode).Temp +
-                                 HWFlow * state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNodeNum).Temp) /
+                                 HWFlow * state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNode).Temp) /
                                 MdotLockH;
-                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNodeNum).Enthalpy =
+                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNode).Enthalpy =
                                 (HWFlowBypass * state.dataLoopNodes->Node(fanCoil.HeatCoilFluidInletNode).Enthalpy +
-                                 HWFlow * state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNodeNum).Enthalpy) /
+                                 HWFlow * state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNode).Enthalpy) /
                                 MdotLockH;
                         } else {
                             // if MdotLockH <= HWFlow use MdotLockH as is
                             state.dataLoopNodes->Node(fanCoil.HeatCoilFluidInletNode).MassFlowRate =
                                 MdotLockH; // reset flow to locked value. Since lock is on, must do this by hand
-                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNodeNum).MassFlowRate = MdotLockH;
+                            state.dataLoopNodes->Node(fanCoil.HeatCoilFluidOutletNode).MassFlowRate = MdotLockH;
                             Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut);
                         }
                     }
@@ -2363,15 +2314,15 @@ namespace FanCoilUnits {
             // zero the hot & cold water flows
             mdot = 0.0;
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
             if (state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).LoopSide(fanCoil.CoolCoilPlantLoc.loopSideNum).FlowLock ==
                 DataPlant::FlowLock::Locked) {
                 ColdFlowLocked = true; // check for flow lock
             }
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                 if (state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).LoopSide(fanCoil.HeatCoilPlantLoc.loopSideNum).FlowLock ==
                     DataPlant::FlowLock::Locked) {
                     HotFlowLocked = true; // save locked flow
@@ -2392,7 +2343,7 @@ namespace FanCoilUnits {
                 // set water side mass flow rate
                 if (QCoilCoolSP < 0) {
                     state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).MassFlowRate = fanCoil.MaxCoolCoilFluidFlow;
-                } else if (QCoilHeatSP > 0 && fanCoil.HCoilType_Num != HCoil::Electric) {
+                } else if (QCoilHeatSP > 0 && fanCoil.heatCoilType != HVAC::CoilType::HeatingElectric) {
                     state.dataLoopNodes->Node(fanCoil.HeatCoilFluidInletNode).MassFlowRate = fanCoil.MaxHeatCoilFluidFlow;
                 }
 
@@ -2421,7 +2372,7 @@ namespace FanCoilUnits {
                 // cooling coil action, maximum cold water flow
                 mdot = fanCoil.MaxCoolCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
 
                 QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToCoolSP;
                 ControlOffset = fanCoil.ColdControlOffset;
@@ -2499,12 +2450,12 @@ namespace FanCoilUnits {
                     }
                     mdot = PLR * fanCoil.MaxCoolCoilFluidFlow;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
                 } else {
                     PLR = 1.0;
                     mdot = PLR * fanCoil.MaxCoolCoilFluidFlow;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
                 }
 
                 // at the end calculate output
@@ -2514,10 +2465,10 @@ namespace FanCoilUnits {
                        state.dataHeatBalFanSys->TempControlType(ControlledZoneNum) != HVAC::SetptType::SingleCool) {
                 // heating coil action, maximun hot water flow
 
-                if (fanCoil.HCoilType_Num == HCoil::Water) {
+                if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                     mdot = fanCoil.MaxHeatCoilFluidFlow;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                 }
 
                 QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToHeatSP;
@@ -2528,7 +2479,7 @@ namespace FanCoilUnits {
                 // calculate the PLR, if load greater than output, PLR = 1 (output = max)
                 if (QUnitOutMax > QZnReq) {
                     // more heating than required, find reduced water flow rate to meet the load
-                    if (fanCoil.HCoilType_Num == HCoil::Water) {
+                    if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                         // solve for the hot water flow rate with no limit set by flow rate lockdown
                         auto f = [&state, FanCoilNum, FirstHVACIteration, ControlledZoneNum, QZnReq](Real64 const PLR) {
                             return CalcFanCoilPLRResidual(state,
@@ -2601,7 +2552,7 @@ namespace FanCoilUnits {
                         }
                         HWFlow = PLR * fanCoil.MaxHeatCoilFluidFlow;
                         PlantUtilities::SetComponentFlowRate(
-                            state, HWFlow, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                            state, HWFlow, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
 
                     } else {
                         auto f = [&state, FirstHVACIteration, FanCoilNum, ControlledZoneNum, QZnReq](Real64 const PartLoadRatio) {
@@ -2611,10 +2562,10 @@ namespace FanCoilUnits {
                     }
                 } else {
                     PLR = 1.0;
-                    if (fanCoil.HCoilType_Num == HCoil::Water) {
+                    if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                         mdot = PLR * fanCoil.MaxHeatCoilFluidFlow;
                         PlantUtilities::SetComponentFlowRate(
-                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                     }
                 }
 
@@ -2654,12 +2605,12 @@ namespace FanCoilUnits {
             //  zero the hot & cold water flows
             mdot = 0.0;
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
 
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
             }
 
             OAMassFlow = 0.0;
@@ -2721,16 +2672,16 @@ namespace FanCoilUnits {
 
                 mdot = fanCoil.MaxCoolCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
 
             } else if (state.dataFanCoilUnits->HeatingLoad) {
 
                 state.dataLoopNodes->Node(InletNode).MassFlowRate = MaxSAMassFlowRate;
 
-                if (fanCoil.HCoilType_Num == HCoil::Water) {
+                if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                     mdot = fanCoil.MaxHeatCoilFluidFlow;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                 }
             }
 
@@ -2745,12 +2696,12 @@ namespace FanCoilUnits {
                         MinSAMassFlowRate; // = min air flow rate + ((max-min) air flow rate * FanPartLoadRatio)
                     mdot = 0.0;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
 
-                    if (fanCoil.HCoilType_Num == HCoil::Water) {
+                    if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                         mdot = 0.0;
                         PlantUtilities::SetComponentFlowRate(
-                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                     }
                 } else {
                     Real64 OnOffAirFlowRatio = 1.0;
@@ -2799,12 +2750,12 @@ namespace FanCoilUnits {
             //    Node(fanCoil%HeatCoilFluidInletNode)%MassFlowRate = 0.0
             mdot = 0.0;
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
 
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
             }
             Calc4PipeFanCoil(state,
                              FanCoilNum,
@@ -2819,7 +2770,7 @@ namespace FanCoilUnits {
                 // cooling coil action, maximum cold water flow
                 mdot = fanCoil.MaxCoolCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                    state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
                 QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToCoolSP;
                 ControlOffset = fanCoil.ColdControlOffset;
 
@@ -2863,10 +2814,10 @@ namespace FanCoilUnits {
             } else if (UnitOn && state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToHeatSP > HVAC::SmallLoad &&
                        state.dataHeatBalFanSys->TempControlType(ControlledZoneNum) != HVAC::SetptType::SingleCool) {
                 // heating coil action, maximun hot water flow
-                if (fanCoil.HCoilType_Num == HCoil::Water) {
+                if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                     mdot = fanCoil.MaxHeatCoilFluidFlow;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                        state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                 }
                 QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToHeatSP;
                 ControlOffset = fanCoil.HotControlOffset;
@@ -3075,7 +3026,7 @@ namespace FanCoilUnits {
         Real64 PLR = 1.0; // operating part-load ratio
         if (WaterControlNode == fanCoil.CoolCoilFluidInletNode) {
             state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxCoolCoilFluidFlow;
-        } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.HCoilType_Num != HCoil::Electric) {
+        } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.heatCoilType != HVAC::CoilType::HeatingElectric) {
             state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxHeatCoilFluidFlow;
         }
         Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut, PLR);
@@ -3085,7 +3036,7 @@ namespace FanCoilUnits {
             // RegulaFalsi can reach max iteration when low water flow rate is required to meet load. Test at 10% of flow before iterating
             if (WaterControlNode == fanCoil.CoolCoilFluidInletNode) {
                 state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxCoolCoilFluidFlow;
-            } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.HCoilType_Num != HCoil::Electric) {
+            } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.heatCoilType != HVAC::CoilType::HeatingElectric) {
                 state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxHeatCoilFluidFlow;
             }
             Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut, PLR);
@@ -3095,7 +3046,7 @@ namespace FanCoilUnits {
                 // RegulaFalsi can reach max iteration when low water flow rate is required to meet load. Test at 1% of flow before iterating
                 if (WaterControlNode == fanCoil.CoolCoilFluidInletNode) {
                     state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxCoolCoilFluidFlow;
-                } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.HCoilType_Num != HCoil::Electric) {
+                } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.heatCoilType != HVAC::CoilType::HeatingElectric) {
                     state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxHeatCoilFluidFlow;
                 }
                 Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut, PLR);
@@ -3105,7 +3056,7 @@ namespace FanCoilUnits {
                     // RegulaFalsi can reach max iteration when low water flow rate is required to meet load. Test at 0.1% of flow before iterating
                     if (WaterControlNode == fanCoil.CoolCoilFluidInletNode) {
                         state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxCoolCoilFluidFlow;
-                    } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.HCoilType_Num != HCoil::Electric) {
+                    } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.heatCoilType != HVAC::CoilType::HeatingElectric) {
                         state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxHeatCoilFluidFlow;
                     }
                     Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut, PLR);
@@ -3116,7 +3067,7 @@ namespace FanCoilUnits {
                         // iterating
                         if (WaterControlNode == fanCoil.CoolCoilFluidInletNode) {
                             state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxCoolCoilFluidFlow;
-                        } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.HCoilType_Num != HCoil::Electric) {
+                        } else if (WaterControlNode == fanCoil.HeatCoilFluidInletNode && fanCoil.heatCoilType != HVAC::CoilType::HeatingElectric) {
                             state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * fanCoil.MaxHeatCoilFluidFlow;
                         }
                         Calc4PipeFanCoil(state, FanCoilNum, ControlledZoneNum, FirstHVACIteration, QUnitOut, PLR);
@@ -3244,23 +3195,22 @@ namespace FanCoilUnits {
             } else { // using 1.0 here for fan speed ratio seems wrong if FCU max flow rate is different than the fan maximum flow rate
                 state.dataFans->fans(fanCoil.FanIndex)->simulate(state, FirstHVACIteration, 0.0, _, 0.0);
             }
-            if (fanCoil.CCoilType_Num == CCoil::HXAssist) {
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
-                    state, fanCoil.CCoilName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, fanCoil.CCoilName_Index, HVAC::FanOp::Continuous);
+            if (fanCoil.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                HXAssistCoil::SimHXAssistedCoolingCoil(
+                    state, fanCoil.CoolCoilNum, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, HVAC::FanOp::Continuous);
             } else {
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, fanCoil.CCoilName, FirstHVACIteration, fanCoil.CCoilName_Index, _, HVAC::FanOp::Cycling, PLR);
+                    state, fanCoil.CoolCoilNum, FirstHVACIteration, _, HVAC::FanOp::Cycling, PLR);
             }
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, fanCoil.HCoilName, FirstHVACIteration, fanCoil.HCoilName_Index, _, HVAC::FanOp::Cycling, PLR);
+                    state, fanCoil.HeatCoilNum, FirstHVACIteration, _, HVAC::FanOp::Cycling, PLR);
             } else {
                 if (state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).MassFlowRate > 0.0) ElecHeaterControl = 0.0;
                 HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                            fanCoil.HCoilName,
+                                                            fanCoil.HeatCoilNum,
                                                             FirstHVACIteration,
                                                             fanCoil.DesignHeatingCapacity * PartLoad * ElecHeaterControl,
-                                                            fanCoil.HCoilName_Index,
                                                             _,
                                                             false,
                                                             HVAC::FanOp::Continuous,
@@ -3275,16 +3225,16 @@ namespace FanCoilUnits {
                 Real64 ActFanFlowRatio = state.dataFanCoilUnits->FanFlowRatio * PartLoad;
                 state.dataFans->fans(fanCoil.FanIndex)->simulate(state, FirstHVACIteration, _, _, ActFanFlowRatio);
             }
-            if (fanCoil.CCoilType_Num == CCoil::HXAssist) {
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
-                    state, fanCoil.CCoilName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, fanCoil.CCoilName_Index, HVAC::FanOp::Continuous);
+            if (fanCoil.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                HXAssistCoil::SimHXAssistedCoolingCoil(
+                    state, fanCoil.CoolCoilNum, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, HVAC::FanOp::Continuous);
             } else {
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, fanCoil.CCoilName, FirstHVACIteration, fanCoil.CCoilName_Index, _, HVAC::FanOp::Cycling, PLR);
+                    state, fanCoil.CoolCoilNum, FirstHVACIteration, _, HVAC::FanOp::Cycling, PLR);
             }
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, fanCoil.HCoilName, FirstHVACIteration, fanCoil.HCoilName_Index, _, HVAC::FanOp::Cycling, PLR);
+                    state, fanCoil.HeatCoilNum, FirstHVACIteration, _, HVAC::FanOp::Cycling, PLR);
             } else {
                 if (state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).MassFlowRate > 0.0) ElecHeaterControl = 0.0;
                 Real64 QZnReq = 0.0;
@@ -3295,10 +3245,10 @@ namespace FanCoilUnits {
                     QZnReq = fanCoil.DesignHeatingCapacity * state.dataFanCoilUnits->FanFlowRatio * PartLoad * eHeatCoilCyclingR * ElecHeaterControl;
                 }
                 HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                            fanCoil.HCoilName,
+                                                            fanCoil.HeatCoilName,
                                                             FirstHVACIteration,
                                                             QZnReq,
-                                                            fanCoil.HCoilName_Index,
+                                                            fanCoil.HeatCoilNum,
                                                             _,
                                                             false,
                                                             fanCoil.fanOp, // fanCoil.FanOpMode, // FanOp::Continuous, FanOp::Cycling
@@ -3314,21 +3264,20 @@ namespace FanCoilUnits {
 
             state.dataFans->fans(fanCoil.FanIndex)->simulate(state, FirstHVACIteration, FanSpeedRatio, _, FanSpeedRatio);
 
-            if (fanCoil.CCoilType_Num == CCoil::HXAssist) {
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
-                    state, fanCoil.CCoilName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, fanCoil.CCoilName_Index, HVAC::FanOp::Continuous);
+            if (fanCoil.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                HXAssistCoil::SimHXAssistedCoolingCoil(
+                    state, fanCoil.CoolCoilNum, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, HVAC::FanOp::Continuous);
             } else {
-                WaterCoils::SimulateWaterCoilComponents(state, fanCoil.CCoilName, FirstHVACIteration, fanCoil.CCoilName_Index);
+                WaterCoils::SimulateWaterCoilComponents(state, fanCoil.CoolCoilNum, FirstHVACIteration);
             }
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
-                WaterCoils::SimulateWaterCoilComponents(state, fanCoil.HCoilName, FirstHVACIteration, fanCoil.HCoilName_Index);
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
+                WaterCoils::SimulateWaterCoilComponents(state, fanCoil.HeatCoilNum, FirstHVACIteration);
             } else {
                 if (state.dataLoopNodes->Node(fanCoil.CoolCoilFluidInletNode).MassFlowRate > 0.0) ElecHeaterControl = 0.0;
                 HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                            fanCoil.HCoilName,
+                                                            fanCoil.HeatCoilNum,
                                                             FirstHVACIteration,
                                                             fanCoil.DesignHeatingCapacity * PartLoad * ElecHeaterControl,
-                                                            fanCoil.HCoilName_Index,
                                                             _,
                                                             false,
                                                             HVAC::FanOp::Continuous,
@@ -3410,14 +3359,14 @@ namespace FanCoilUnits {
         state.dataLoopNodes->Node(InletNode).MassFlowRateMaxAvail = AirMassFlow;
         state.dataLoopNodes->Node(InletNode).MassFlowRateMinAvail = AirMassFlow;
 
-        if (fanCoil.HCoilType_Num == HCoil::Water) {
+        if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
             mdot = 0.0;
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
         }
         mdot = 0.0;
         PlantUtilities::SetComponentFlowRate(
-            state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+            state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
         // no load output, requires setting eHeatCoilCyclingR = 0.0, for electric heating coils
         Calc4PipeFanCoil(state, FanCoilNum, ZoneNum, FirstHVACIteration, QUnitOutNoHC, _, 0.0);
 
@@ -3536,14 +3485,14 @@ namespace FanCoilUnits {
         }
 
         if (UnitOn && QZnReq < (-1.0 * FanCoilUnits::Small5WLoad) && CoolingLoad) {
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
             }
             mdot = fanCoil.MaxCoolCoilFluidFlow;
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
             // select fan speed
             fanCoil.SpeedFanSel = 1;
             fanCoil.SpeedFanRatSel = fanCoil.LowSpeedRatio;
@@ -3581,12 +3530,12 @@ namespace FanCoilUnits {
 
             mdot = 0.0;
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
 
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 mdot = fanCoil.MaxHeatCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
             }
             // select fan speed
             fanCoil.SpeedFanSel = 1;
@@ -3648,12 +3597,12 @@ namespace FanCoilUnits {
             }
 
             mdot = 0.0;
-            if (fanCoil.HCoilType_Num == HCoil::Water) {
+            if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                    state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
             }
             PlantUtilities::SetComponentFlowRate(
-                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
             // No load output, eHeatCoilCyclingR = 0.0 for electric heating coil
             Calc4PipeFanCoil(state, FanCoilNum, ZoneNum, FirstHVACIteration, QUnitOut, PartLoadRatio, 0.0);
         }
@@ -3732,7 +3681,7 @@ namespace FanCoilUnits {
                     inletNode.MassFlowRateMinAvail = inletNode.MassFlowRate;
                     mdot = PLR * fanCoil.MaxCoolCoilFluidFlow;
                     PlantUtilities::SetComponentFlowRate(
-                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNodeNum, fanCoil.CoolCoilPlantLoc);
+                        state, mdot, fanCoil.CoolCoilFluidInletNode, fanCoil.CoolCoilFluidOutletNode, fanCoil.CoolCoilPlantLoc);
                     if (fanCoil.fanOp == HVAC::FanOp::Continuous) {
                         Calc4PipeFanCoil(state, FanCoilNum, ZoneNum, FirstHVACIteration, QUnitOut);
                     } else {
@@ -3845,13 +3794,13 @@ namespace FanCoilUnits {
                 Calc4PipeFanCoil(state, FanCoilNum, ZoneNum, FirstHVACIteration, QUnitOutMax);
                 PLR = std::abs(QZnReq / QUnitOutMax);
                 if (PLR > 1.0) PLR = 1.0;
-                if (fanCoil.HCoilType_Num == HCoil::Water) {
+                if (fanCoil.heatCoilType == HVAC::CoilType::HeatingWater) {
                     // adjust the PLR to meet the heating load by calling Calc4PipeFanCoil repeatedly
                     while (std::abs(Error) > ControlOffset && std::abs(AbsError) > FanCoilUnits::Small5WLoad && Iter < MaxIterCycl && PLR != 1.0) {
                         inletNode.MassFlowRateMinAvail = inletNode.MassFlowRate;
                         mdot = PLR * fanCoil.MaxHeatCoilFluidFlow;
                         PlantUtilities::SetComponentFlowRate(
-                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNodeNum, fanCoil.HeatCoilPlantLoc);
+                            state, mdot, fanCoil.HeatCoilFluidInletNode, fanCoil.HeatCoilFluidOutletNode, fanCoil.HeatCoilPlantLoc);
                         if (fanCoil.fanOp == HVAC::FanOp::Continuous) {
                             Calc4PipeFanCoil(state, FanCoilNum, ZoneNum, FirstHVACIteration, QUnitOut);
                         } else {
@@ -4196,7 +4145,7 @@ namespace FanCoilUnits {
                              QUnitOut,
                              PLR); // needs PLR=0 for electric heating coil, otherwise will run a full capacity
         } else if (WaterControlNode == state.dataFanCoilUnits->FanCoil(FanCoilNum).HeatCoilFluidInletNode &&
-                   state.dataFanCoilUnits->FanCoil(FanCoilNum).HCoilType_Num != HCoil::Electric) {
+                   state.dataFanCoilUnits->FanCoil(FanCoilNum).heatCoilType != HVAC::CoilType::HeatingElectric) {
             state.dataLoopNodes->Node(WaterControlNode).MassFlowRate = PLR * state.dataFanCoilUnits->FanCoil(FanCoilNum).MaxHeatCoilFluidFlow;
             Calc4PipeFanCoil(state,
                              FanCoilNum,
@@ -4296,7 +4245,7 @@ namespace FanCoilUnits {
         Real64 QUnitOut;
         if (WaterControlNode == state.dataFanCoilUnits->FanCoil(FanCoilNum).CoolCoilFluidInletNode ||
             (WaterControlNode == state.dataFanCoilUnits->FanCoil(FanCoilNum).HeatCoilFluidInletNode &&
-             state.dataFanCoilUnits->FanCoil(FanCoilNum).HCoilType_Num != HCoil::Electric)) {
+             state.dataFanCoilUnits->FanCoil(FanCoilNum).heatCoilType != HVAC::CoilType::HeatingElectric)) {
 
             Calc4PipeFanCoil(state,
                              FanCoilNum,
diff --git a/src/EnergyPlus/FanCoilUnits.hh b/src/EnergyPlus/FanCoilUnits.hh
index ae0cde9e776..2c4eac7b18d 100644
--- a/src/EnergyPlus/FanCoilUnits.hh
+++ b/src/EnergyPlus/FanCoilUnits.hh
@@ -76,22 +76,6 @@ namespace FanCoilUnits {
     // coil type units supported in this module
     constexpr int FanCoilUnit_4Pipe(1);
 
-    enum class CCoil
-    {
-        Invalid = -1,
-        Water,
-        Detailed,
-        HXAssist,
-        Num
-    };
-
-    enum class HCoil
-    {
-        Invalid = -1,
-        Water,
-        Electric,
-        Num
-    };
 
     enum class CCM // capacity control method supported in this module
     {
@@ -140,27 +124,33 @@ namespace FanCoilUnits {
         int OAMixIndex = 0;
         std::string FanName;     // name of fan
         int FanIndex = 0;        // index for fan
-        std::string CCoilName;   // name of cooling coil
-        int CCoilName_Index = 0; // Index for this Cooling Coil in SimWaterComp
-        std::string CCoilType;   // type of cooling coil:
+
+        std::string CoolCoilName;
+        int CoolCoilNum = 0;
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;
+      
+        // If the cooling coil is HX assisted, then this is the embedded "child" coil
+        std::string childCoolCoilName;   // name of cooling coil
+        int childCoolCoilNum = 0; // Index for this Cooling Coil in SimWaterComp
+        HVAC::CoilType childCoolCoilType = HVAC::CoilType::Invalid;   // type of cooling coil:
         // 'Coil:Cooling:Water' or
         // 'Coil:Cooling:Water:DetailedGeometry' or
         // 'CoilSystem:Cooling:Water:HeatExchangerAssisted'
-        CCoil CCoilType_Num = CCoil::Invalid; // Numeric equivalent for type of cooling coil
-        std::string CCoilPlantName;           // name of cooling coil (child<=CoilSystem:Cooling:Water:HeatExchangerAssisted)
-        DataPlant::PlantEquipmentType CCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+        DataPlant::PlantEquipmentType CoolCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+      
         int ControlCompTypeNum = 0;
         int CompErrIndex = 0;
         Real64 MaxColdWaterVolFlow = 0.0; // m3/s
         Real64 MinColdWaterVolFlow = 0.0; // m3/s
         Real64 MinColdWaterFlow = 0.0;    // kg/s
         Real64 ColdControlOffset = 0.0;   // control tolerance
-        std::string HCoilName;            // name of heating coil
-        int HCoilName_Index = 0;
-        std::string HCoilType; // type of heating coil:
+
+        std::string HeatCoilName;            // name of heating coil
+        int HeatCoilNum = 0;
+
         // 'Coil:Heating:Water' or
-        HCoil HCoilType_Num = HCoil::Invalid; // Numeric equivalent for type of cooling coil
-        DataPlant::PlantEquipmentType HCoilPlantTypeOf = DataPlant::PlantEquipmentType::Invalid;
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid; // Numeric equivalent for type of cooling coil
+        DataPlant::PlantEquipmentType HeatCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
         Real64 MaxHotWaterVolFlow = 0.0;    // m3/s
         Real64 MinHotWaterVolFlow = 0.0;    // m3/s
         Real64 MinHotWaterFlow = 0.0;       // kg/s
@@ -216,15 +206,15 @@ namespace FanCoilUnits {
         Real64 LowSpeedCoolFanRatio = 0.0;     // ratio of min air flow to max air flow
         Real64 LowSpeedHeatFanRatio = 0.0;     // ratio of min air flow to max air flow
         int CoolCoilFluidInletNode = 0;        // chilled water control node
-        int CoolCoilFluidOutletNodeNum = 0;    // chilled water coil outlet plant node
+        int CoolCoilFluidOutletNode = 0;    // chilled water coil outlet plant node
         int HeatCoilFluidInletNode = 0;        // hot water control node
-        int HeatCoilFluidOutletNodeNum = 0;    // hot water coil outlet plant node
+        int HeatCoilFluidOutletNode = 0;    // hot water coil outlet plant node
         PlantLocation CoolCoilPlantLoc{};      // index for plant location for chilled water coil
         PlantLocation HeatCoilPlantLoc{};      // index for plant location for hot water coil
-        int CoolCoilInletNodeNum = 0;          // index of cooling coil inlet node number
-        int CoolCoilOutletNodeNum = 0;         // index of cooling coil outlet node number
-        int HeatCoilInletNodeNum = 0;          // index of heating coil inlet node number
-        int HeatCoilOutletNodeNum = 0;         // index of heating coil outlet node number
+        int CoolCoilAirInletNode = 0;          // index of cooling coil inlet node number
+        int CoolCoilAirOutletNode = 0;         // index of cooling coil outlet node number
+        int HeatCoilAirInletNode = 0;          // index of heating coil inlet node number
+        int HeatCoilAirOutletNode = 0;         // index of heating coil outlet node number
         int ControlZoneNum = 0;                // pointer to a zone served by a fancoil unit
         int NodeNumOfControlledZone = 0;       // node number of controlled zone
         bool ATMixerExists = false;            // True if there is an ATMixer
@@ -414,8 +404,6 @@ struct FanCoilUnitsData : BaseGlobalStruct
     Array1D_bool MyEnvrnFlag;
     Array1D_bool MyPlantScanFlag;
     Array1D_bool MyZoneEqFlag; // used to set up zone equipment availability managers
-    int CoilWaterInletNode = 0;
-    int CoilWaterOutletNode = 0;
     int ATMixOutNode = 0; // outlet node of ATM Mixer
     int ZoneNode = 0;     // zone node
 
diff --git a/src/EnergyPlus/FaultsManager.cc b/src/EnergyPlus/FaultsManager.cc
index 5bc5184862e..bb790a97837 100644
--- a/src/EnergyPlus/FaultsManager.cc
+++ b/src/EnergyPlus/FaultsManager.cc
@@ -163,6 +163,7 @@ namespace FaultsManager {
         Num
     };
 
+#ifdef GET_OUT  
     enum class CoilType
     {
         Invalid = -1,
@@ -178,7 +179,8 @@ namespace FaultsManager {
         AirLoopHVACUnitarySystem,
         Num
     };
-
+#endif // GET_OUT
+  
     constexpr std::array<std::string_view, static_cast<int>(ChillerType::Num)> ChillerTypeNamesUC{"CHILLER:ELECTRIC",
                                                                                                   "CHILLER:ELECTRIC:EIR",
                                                                                                   "CHILLER:ELECTRIC:REFORMULATEDEIR",
@@ -188,6 +190,7 @@ namespace FaultsManager {
                                                                                                   "CHILLER:ABSORPTION",
                                                                                                   "CHILLER:ABSORPTION:INDIRECT"};
 
+#ifdef GET_OUT  
     constexpr std::array<std::string_view, static_cast<int>(CoilType::Num)> CoilTypeNamesUC{"COIL:HEATING:ELECTRIC",
                                                                                             "COIL:HEATING:FUEL",
                                                                                             "COIL:HEATING:DESUPERHEATER",
@@ -198,7 +201,8 @@ namespace FaultsManager {
                                                                                             "COILSYSTEM:COOLING:DX",
                                                                                             "COILSYSTEM:HEATING:DX",
                                                                                             "AIRLOOPHVAC:UNITARYSYSTEM"};
-
+#endif // GET_OUT
+  
     constexpr std::array<std::string_view, static_cast<int>(FouledCoil::Num)> FouledCoilNamesUC{"FOULEDUARATED", "FOULINGFACTOR"};
 
     void CheckAndReadFaults(EnergyPlusData &state)
@@ -749,7 +753,7 @@ namespace FaultsManager {
 
         // read faults input of Coil SAT Sensor Offset
         for (int jFault_CoilSAT = 1; jFault_CoilSAT <= state.dataFaultsMgr->NumFaultyCoilSATSensor; ++jFault_CoilSAT) {
-            auto &faultsCoilSATFouling = state.dataFaultsMgr->FaultsCoilSATSensor(jFault_CoilSAT);
+            auto &faultCoilSAT = state.dataFaultsMgr->FaultsCoilSATSensor(jFault_CoilSAT);
 
             cFaultCurrentObject = cFaults(12); // fault object string
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -766,84 +770,68 @@ namespace FaultsManager {
                                                                      cNumericFieldNames);
 
             ErrorObjectHeader eoh{routineName, cFaultCurrentObject, cAlphaArgs(1)};
-            faultsCoilSATFouling.type = FaultType::TemperatureSensorOffset_CoilSupplyAir;
-            faultsCoilSATFouling.Name = cAlphaArgs(1);
+            faultCoilSAT.type = FaultType::TemperatureSensorOffset_CoilSupplyAir;
+            faultCoilSAT.Name = cAlphaArgs(1);
 
             // Fault availability schedule
             if (lAlphaFieldBlanks(2)) {
-                faultsCoilSATFouling.availSched = Sched::GetScheduleAlwaysOn(state); // returns schedule value of 1
-            } else if ((faultsCoilSATFouling.availSched = Sched::GetSchedule(state, cAlphaArgs(2))) == nullptr) {
+                faultCoilSAT.availSched = Sched::GetScheduleAlwaysOn(state); // returns schedule value of 1
+            } else if ((faultCoilSAT.availSched = Sched::GetSchedule(state, cAlphaArgs(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(2), cAlphaArgs(2));
                 state.dataFaultsMgr->ErrorsFound = true;
             }
 
             // Fault severity schedule
             if (lAlphaFieldBlanks(3)) {
-                faultsCoilSATFouling.severitySched = Sched::GetScheduleAlwaysOn(state); // not an availability schedule, but defaults to constant-1.0
-            } else if ((faultsCoilSATFouling.severitySched = Sched::GetSchedule(state, cAlphaArgs(3))) == nullptr) {
+                faultCoilSAT.severitySched = Sched::GetScheduleAlwaysOn(state); // not an availability schedule, but defaults to constant-1.0
+            } else if ((faultCoilSAT.severitySched = Sched::GetSchedule(state, cAlphaArgs(3))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(3), cAlphaArgs(3));
                 state.dataFaultsMgr->ErrorsFound = true;
             }
 
             // offset - degree of fault
-            faultsCoilSATFouling.Offset = rNumericArgs(1);
+            faultCoilSAT.Offset = rNumericArgs(1);
 
             // Coil type
-            faultsCoilSATFouling.CoilType = cAlphaArgs(4);
             if (lAlphaFieldBlanks(4)) {
-                ShowSevereError(
-                    state, format("{} = \"{}\" invalid {} = \"{}\" blank.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(4), cAlphaArgs(4)));
+                ShowSevereEmptyField(state, eoh, cAlphaFieldNames(4));
+                state.dataFaultsMgr->ErrorsFound = true;
+            } else if ((faultCoilSAT.coilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, cAlphaArgs(4)))) == HVAC::CoilType::Invalid) {
+                ShowSevereInvalidKey(state, eoh, cAlphaFieldNames(4), cAlphaArgs(4));
                 state.dataFaultsMgr->ErrorsFound = true;
             }
 
             // Coil name
-            faultsCoilSATFouling.CoilName = cAlphaArgs(5);
+            faultCoilSAT.CoilName = cAlphaArgs(5);
             if (lAlphaFieldBlanks(5)) {
-                ShowSevereError(
-                    state, format("{} = \"{}\" invalid {} = \"{}\" blank.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(5), cAlphaArgs(5)));
+                ShowSevereEmptyField(state, eoh, cAlphaFieldNames(5));
                 state.dataFaultsMgr->ErrorsFound = true;
             }
 
-            // Coil check and link
-            CoilType CoilTypeCheck = static_cast<CoilType>(getEnumValue(CoilTypeNamesUC, Util::makeUPPER(faultsCoilSATFouling.CoilType)));
-            switch (CoilTypeCheck) {
-            case CoilType::CoilHeatingElectric:
-            case CoilType::CoilHeatingFuel:
-            case CoilType::CoilHeatingDesuperheater: {
-                // Read in coil input if not done yet
-                if (state.dataHeatingCoils->GetCoilsInputFlag) {
-                    HeatingCoils::GetHeatingCoilInput(state);
-                    state.dataHeatingCoils->GetCoilsInputFlag = false;
-                }
-                // Check the coil name and coil type
-                int CoilNum = Util::FindItemInList(faultsCoilSATFouling.CoilName, state.dataHeatingCoils->HeatingCoil);
-                if (CoilNum <= 0) {
-                    ShowSevereError(
-                        state,
-                        format("{} = \"{}\" invalid {} = \"{}\" not found.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(5), cAlphaArgs(5)));
+            switch (faultCoilSAT.coilType) {
+            case HVAC::CoilType::HeatingElectric:
+            case HVAC::CoilType::HeatingGasOrOtherFuel:
+            case HVAC::CoilType::HeatingDesuperheater: {
+                faultCoilSAT.CoilNum = HeatingCoils::GetCoilIndex(state, faultCoilSAT.CoilName);
+                if (faultCoilSAT.CoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(5), cAlphaArgs(5));
                     state.dataFaultsMgr->ErrorsFound = true;
                 } else {
                     // Link the coil with the fault model
-                    state.dataHeatingCoils->HeatingCoil(CoilNum).FaultyCoilSATFlag = true;
-                    state.dataHeatingCoils->HeatingCoil(CoilNum).FaultyCoilSATIndex = jFault_CoilSAT;
+                    auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(faultCoilSAT.CoilNum);
+                    heatingCoil.FaultyCoilSATFlag = true;
+                    heatingCoil.FaultyCoilSATIndex = jFault_CoilSAT;
                 }
             } break;
-            case CoilType::CoilHeatingSteam: {
-                // Read in coil input if not done yet
-                if (state.dataSteamCoils->GetSteamCoilsInputFlag) {
-                    SteamCoils::GetSteamCoilInput(state);
-                    state.dataSteamCoils->GetSteamCoilsInputFlag = false;
-                }
-                // Check the coil name and coil type
-                int CoilNum = Util::FindItemInList(faultsCoilSATFouling.CoilName, state.dataSteamCoils->SteamCoil);
-                if (CoilNum <= 0) {
-                    ShowSevereError(
-                        state,
-                        format("{} = \"{}\" invalid {} = \"{}\" not found.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(5), cAlphaArgs(5)));
+              
+            case HVAC::CoilType::HeatingSteam: {
+                faultCoilSAT.CoilNum = SteamCoils::GetCoilIndex(state, faultCoilSAT.CoilName);
+                if (faultCoilSAT.CoilNum <= 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(5), cAlphaArgs(5));
                     state.dataFaultsMgr->ErrorsFound = true;
                 } else {
-
-                    if (state.dataSteamCoils->SteamCoil(CoilNum).TypeOfCoil != SteamCoils::CoilControlType::TemperatureSetPoint) {
+                    auto &steamCoil = state.dataSteamCoils->SteamCoil(faultCoilSAT.CoilNum);
+                    if (steamCoil.TypeOfCoil != SteamCoils::CoilControlType::TemperatureSetPoint) {
                         // The fault model is only applicable to the coils controlled on leaving air temperature
                         ShowWarningError(state,
                                          format("{} = \"{}\" invalid {} = \"{}\". The specified coil is not controlled on leaving air temperature. "
@@ -854,71 +842,64 @@ namespace FaultsManager {
                                                 cAlphaArgs(5)));
                     } else {
                         // Link the fault model with the coil that is controlled on leaving air temperature
-                        state.dataSteamCoils->SteamCoil(CoilNum).FaultyCoilSATFlag = true;
-                        state.dataSteamCoils->SteamCoil(CoilNum).FaultyCoilSATIndex = jFault_CoilSAT;
+                        steamCoil.FaultyCoilSATFlag = true;
+                        steamCoil.FaultyCoilSATIndex = jFault_CoilSAT;
                     }
                 }
             } break;
-            case CoilType::CoilHeatingWater:
-            case CoilType::CoilCoolingWater:
-            case CoilType::CoilCoolingWaterDetailedgeometry: {
-                // Read in coil input if not done yet
-                if (state.dataWaterCoils->GetWaterCoilsInputFlag) {
-                    WaterCoils::GetWaterCoilInput(state);
-                    state.dataWaterCoils->GetWaterCoilsInputFlag = false;
-                }
-                // Check the coil name and coil type
-                int CoilNum = Util::FindItemInList(faultsCoilSATFouling.CoilName, state.dataWaterCoils->WaterCoil);
-                if (CoilNum <= 0) {
-                    ShowSevereError(
-                        state,
-                        format("{} = \"{}\" invalid {} = \"{}\" not found.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(5), cAlphaArgs(5)));
-                    state.dataFaultsMgr->ErrorsFound = true;
-                }
-
-                // Read in Water Coil Controller Name
-                faultsCoilSATFouling.WaterCoilControllerName = cAlphaArgs(6);
-                if (lAlphaFieldBlanks(6)) {
-                    ShowSevereError(
-                        state,
-                        format("{} = \"{}\" invalid {} = \"{}\" blank.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(6), cAlphaArgs(6)));
-                    state.dataFaultsMgr->ErrorsFound = true;
-                }
-                // Read in controller input if not done yet
-                if (state.dataHVACControllers->GetControllerInputFlag) {
-                    HVACControllers::GetControllerInput(state);
-                    state.dataHVACControllers->GetControllerInputFlag = false;
-                }
-                // Check the controller name
-                int ControlNum = Util::FindItemInList(faultsCoilSATFouling.WaterCoilControllerName,
-                                                      state.dataHVACControllers->ControllerProps,
-                                                      &HVACControllers::ControllerPropsType::ControllerName);
-                if (ControlNum <= 0) {
-                    ShowSevereError(
-                        state,
-                        format("{} = \"{}\" invalid {} = \"{}\" not found.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(6), cAlphaArgs(6)));
+              
+            case HVAC::CoilType::HeatingWater:
+            case HVAC::CoilType::CoolingWater:
+            case HVAC::CoilType::CoolingWaterDetailed: {
+                faultCoilSAT.CoilNum = WaterCoils::GetCoilIndex(state, faultCoilSAT.CoilName);
+                if (faultCoilSAT.CoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(5), cAlphaArgs(5));
                     state.dataFaultsMgr->ErrorsFound = true;
                 } else {
-                    // Link the controller with the fault model
-                    state.dataHVACControllers->ControllerProps(ControlNum).FaultyCoilSATFlag = true;
-                    state.dataHVACControllers->ControllerProps(ControlNum).FaultyCoilSATIndex = jFault_CoilSAT;
-
-                    // Check whether the controller match the coil
-                    if (state.dataHVACControllers->ControllerProps(ControlNum).SensedNode !=
-                        state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum) {
-                        ShowSevereError(state,
-                                        format("{} = \"{}\" invalid {} = \"{}\" does not match {} = \"{}",
-                                               cFaultCurrentObject,
-                                               cAlphaArgs(1),
-                                               cAlphaFieldNames(6),
-                                               cAlphaArgs(6),
-                                               cAlphaFieldNames(5),
-                                               cAlphaArgs(5)));
+
+                    // Read in Water Coil Controller Name
+                    faultCoilSAT.WaterCoilControllerName = cAlphaArgs(6);
+                    if (lAlphaFieldBlanks(6)) {
+                        ShowSevereEmptyField(state, eoh, cAlphaFieldNames(6));
                         state.dataFaultsMgr->ErrorsFound = true;
                     }
+                    
+                    // Read in controller input if not done yet <-- this has to stop
+                    if (state.dataHVACControllers->GetControllerInputFlag) {
+                        HVACControllers::GetControllerInput(state);
+                        state.dataHVACControllers->GetControllerInputFlag = false;
+                    }
+
+                    // Check the controller name
+                    faultCoilSAT.ControllerNum = Util::FindItemInList(faultCoilSAT.WaterCoilControllerName,
+                                                                      state.dataHVACControllers->ControllerProps,
+                                                                      &HVACControllers::ControllerPropsType::ControllerName);
+                    if (faultCoilSAT.ControllerNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(6), cAlphaArgs(6));
+                        state.dataFaultsMgr->ErrorsFound = true;
+                    } else {
+                        auto &controller = state.dataHVACControllers->ControllerProps(faultCoilSAT.ControllerNum);
+                        // Link the controller with the fault model
+                        controller.FaultyCoilSATFlag = true;
+                        controller.FaultyCoilSATIndex = jFault_CoilSAT;
+                        
+                        // Check whether the controller match the coil
+                        if (controller.SensedNode != state.dataWaterCoils->WaterCoil(faultCoilSAT.CoilNum).AirOutletNodeNum) {
+                            ShowSevereError(state,
+                                            format("{} = \"{}\" invalid {} = \"{}\" does not match {} = \"{}",
+                                                   cFaultCurrentObject,
+                                                   cAlphaArgs(1),
+                                                   cAlphaFieldNames(6),
+                                                   cAlphaArgs(6),
+                                                   cAlphaFieldNames(5),
+                                                   cAlphaArgs(5)));
+                            state.dataFaultsMgr->ErrorsFound = true;
+                        }
+                    }
                 }
             } break;
-            case CoilType::CoilSystemCoolingDX: {
+                
+            case HVAC::CoilType::CoolingSystemDX: {
                 // see case CoilCheck::AirLoopHVACUnitarySystem: below
                 // UnitarySystem connects a different way. Make sure this works by testing a CoilSystem model.
                 // Read in DXCoolingSystem input if not done yet
@@ -939,29 +920,26 @@ namespace FaultsManager {
                 //    state.dataHVACDXSys->DXCoolingSystem(CoilSysNum).FaultyCoilSATIndex = jFault_CoilSAT;
                 //}
             } break;
-            case CoilType::CoilSystemHeatingDX: {
-                // Read in DXCoolingSystem input if not done yet
-                if (state.dataHVACDXHeatPumpSys->GetInputFlag) {
-                    HVACDXHeatPumpSystem::GetDXHeatPumpSystemInput(state);
-                    state.dataHVACDXHeatPumpSys->GetInputFlag = false;
-                }
-
-                // Check the coil name and coil type
-                int CoilSysNum = Util::FindItemInList(faultsCoilSATFouling.CoilName, state.dataHVACDXHeatPumpSys->DXHeatPumpSystem);
-                if (CoilSysNum <= 0) {
-                    ShowSevereError(
-                        state,
-                        format("{} = \"{}\" invalid {} = \"{}\" not found.", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(5), cAlphaArgs(5)));
+              
+            case HVAC::CoilType::HeatingSystemDX: {
+                faultCoilSAT.CoilNum = HVACDXHeatPumpSystem::GetCoilIndex(state, faultCoilSAT.CoilName);
+                if (faultCoilSAT.CoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(5), cAlphaArgs(5));
                     state.dataFaultsMgr->ErrorsFound = true;
                 } else {
+                    auto &dxhpSys = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(faultCoilSAT.CoilNum);
                     // Link the coil system with the fault model
-                    state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(CoilSysNum).FaultyCoilSATFlag = true;
-                    state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(CoilSysNum).FaultyCoilSATIndex = jFault_CoilSAT;
+                    dxhpSys.FaultyCoilSATFlag = true;
+                    dxhpSys.FaultyCoilSATIndex = jFault_CoilSAT;
                 }
             } break;
+              
+#ifdef GET_OUT
             case CoilType::AirLoopHVACUnitarySystem: {
                 // UnitarySystem model connects to FaultManager via function call to FaultsManager::SetFaultyCoilSATSensor
             } break;
+#endif // GET_OUT              
+
             default:
                 break;
             }
@@ -1609,7 +1587,7 @@ namespace FaultsManager {
             ErrorObjectHeader eoh{routineName, cFaultCurrentObject, cAlphaArgs(1)};
             faultsFoulCoil.type = FaultType::Fouling_Coil;
             faultsFoulCoil.Name = cAlphaArgs(1);
-            faultsFoulCoil.FouledCoilName = cAlphaArgs(2);
+            faultsFoulCoil.CoilName = cAlphaArgs(2);
 
             // Availability schedule
             if (lAlphaFieldBlanks(3)) {
@@ -1639,113 +1617,101 @@ namespace FaultsManager {
             faultsFoulCoil.Aratio = rNumericArgs(5);
 
             // Coil check and link
-            {
-                // Obtains and Allocates WaterCoil related parameters from input file
-                if (state.dataWaterCoils->GetWaterCoilsInputFlag) {
-                    WaterCoils::GetWaterCoilInput(state);
-                    state.dataWaterCoils->GetWaterCoilsInputFlag = false;
-                }
+            faultsFoulCoil.CoilNum = WaterCoils::GetCoilIndex(state, faultsFoulCoil.CoilName); 
+            if (faultsFoulCoil.CoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(2), faultsFoulCoil.CoilName);
+                state.dataFaultsMgr->ErrorsFound = true;
+            } else {
+                // Coil is found: check if the right type
+                auto &waterCoil = state.dataWaterCoils->WaterCoil(faultsFoulCoil.CoilNum);
+                if ((waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
+                    (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling)) {
+                    // Link the Coil with the fault model
+                    waterCoil.FaultyCoilFoulingFlag = true;
+                    waterCoil.FaultyCoilFoulingIndex = jFault_FoulingCoil;
+
+                    faultsFoulCoil.coilPlantType = waterCoil.coilPlantType;
+                    faultsFoulCoil.CoilNum = faultsFoulCoil.CoilNum;
+
+                    SetupOutputVariable(state,
+                                        "Coil Fouling Factor",
+                                        Constant::Units::K_W,
+                                        waterCoil.FaultyCoilFoulingFactor,
+                                        OutputProcessor::TimeStepType::System,
+                                        OutputProcessor::StoreType::Average,
+                                        waterCoil.Name);
+
+                    // Coil:Cooling:Water doesn't report UA because it's not variable,
+                    // but here, it's useful since we do change it via fouling, so report it
+                    if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
+                        SetupOutputVariable(state,
+                                            "Cooling Coil Total U Factor Times Area Value",
+                                            Constant::Units::W_K,
+                                            waterCoil.UACoilTotal,
+                                            OutputProcessor::TimeStepType::System,
+                                            OutputProcessor::StoreType::Average,
+                                            waterCoil.Name);
 
-                // Check the coil name and type
-                int CoilNum = Util::FindItemInList(faultsFoulCoil.FouledCoilName, state.dataWaterCoils->WaterCoil);
-                if (CoilNum <= 0) {
-                    ShowSevereError(state,
-                                    format("{} = \"{}\". Referenced Coil named \"{}\" was not found.",
-                                           cFaultCurrentObject,
-                                           cAlphaArgs(1),
-                                           faultsFoulCoil.FouledCoilName));
-                    state.dataFaultsMgr->ErrorsFound = true;
-                } else {
-                    // Coil is found: check if the right type
-                    if ((state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
-                        (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling)) {
-                        // Link the Coil with the fault model
-                        state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag = true;
-                        state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex = jFault_FoulingCoil;
+                        SetupOutputVariable(state,
+                                            "Cooling Coil External U Factor Times Area Value",
+                                            Constant::Units::W_K,
+                                            waterCoil.UACoilExternal,
+                                            OutputProcessor::TimeStepType::System,
+                                            OutputProcessor::StoreType::Average,
+                                            waterCoil.Name);
 
-                        faultsFoulCoil.FouledCoilType = state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType;
-                        faultsFoulCoil.FouledCoilNum = CoilNum;
+                        SetupOutputVariable(state,
+                                            "Cooling Coil Internal U Factor Times Area Value",
+                                            Constant::Units::W_K,
+                                            waterCoil.UACoilInternal,
+                                            OutputProcessor::TimeStepType::System,
+                                            OutputProcessor::StoreType::Average,
+                                            waterCoil.Name);
 
                         SetupOutputVariable(state,
-                                            "Coil Fouling Factor",
-                                            Constant::Units::K_W,
-                                            state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFactor,
+                                            "Cooling Coil Total U Factor Times Area Value Before Fouling",
+                                            Constant::Units::W_K,
+                                            waterCoil.OriginalUACoilVariable,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Average,
-                                            state.dataWaterCoils->WaterCoil(CoilNum).Name);
-
-                        // Coil:Cooling:Water doesn't report UA because it's not variable,
-                        // but here, it's useful since we do change it via fouling, so report it
-                        if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
-                            SetupOutputVariable(state,
-                                                "Cooling Coil Total U Factor Times Area Value",
-                                                Constant::Units::W_K,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal,
-                                                OutputProcessor::TimeStepType::System,
-                                                OutputProcessor::StoreType::Average,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).Name);
-
-                            SetupOutputVariable(state,
-                                                "Cooling Coil External U Factor Times Area Value",
-                                                Constant::Units::W_K,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal,
-                                                OutputProcessor::TimeStepType::System,
-                                                OutputProcessor::StoreType::Average,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).Name);
-
-                            SetupOutputVariable(state,
-                                                "Cooling Coil Internal U Factor Times Area Value",
-                                                Constant::Units::W_K,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal,
-                                                OutputProcessor::TimeStepType::System,
-                                                OutputProcessor::StoreType::Average,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).Name);
-
-                            SetupOutputVariable(state,
-                                                "Cooling Coil Total U Factor Times Area Value Before Fouling",
-                                                Constant::Units::W_K,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable,
-                                                OutputProcessor::TimeStepType::System,
-                                                OutputProcessor::StoreType::Average,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).Name);
-
-                            SetupOutputVariable(state,
-                                                "Cooling Coil External U Factor Times Area Value Before Fouling",
-                                                Constant::Units::W_K,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilExternal,
-                                                OutputProcessor::TimeStepType::System,
-                                                OutputProcessor::StoreType::Average,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).Name);
-
-                            SetupOutputVariable(state,
-                                                "Cooling Coil Internal U Factor Times Area Value Before Fouling",
-                                                Constant::Units::W_K,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilInternal,
-                                                OutputProcessor::TimeStepType::System,
-                                                OutputProcessor::StoreType::Average,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).Name);
-
-                        } else {
-                            SetupOutputVariable(state,
-                                                "Heating Coil U Factor Times Area Value Before Fouling",
-                                                Constant::Units::W_K,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable,
-                                                OutputProcessor::TimeStepType::System,
-                                                OutputProcessor::StoreType::Average,
-                                                state.dataWaterCoils->WaterCoil(CoilNum).Name);
-                        }
+                                            waterCoil.Name);
+
+                        SetupOutputVariable(state,
+                                            "Cooling Coil External U Factor Times Area Value Before Fouling",
+                                            Constant::Units::W_K,
+                                            waterCoil.OriginalUACoilExternal,
+                                            OutputProcessor::TimeStepType::System,
+                                            OutputProcessor::StoreType::Average,
+                                            waterCoil.Name);
+
+                        SetupOutputVariable(state,
+                                            "Cooling Coil Internal U Factor Times Area Value Before Fouling",
+                                            Constant::Units::W_K,
+                                            waterCoil.OriginalUACoilInternal,
+                                            OutputProcessor::TimeStepType::System,
+                                            OutputProcessor::StoreType::Average,
+                                            waterCoil.Name);
+                        
                     } else {
-                        ShowSevereError(
-                            state,
-                            format("{} = \"{}\" invalid {} = \"{}\".", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(2), cAlphaArgs(2)));
-                        ShowContinueError(
-                            state, R"(Coil was found but it is not one of the supported types ("Coil:Cooling:Water" or "Coil:Heating:Water").)");
-                        state.dataFaultsMgr->ErrorsFound = true;
+                        SetupOutputVariable(state,
+                                            "Heating Coil U Factor Times Area Value Before Fouling",
+                                            Constant::Units::W_K,
+                                            waterCoil.OriginalUACoilVariable,
+                                            OutputProcessor::TimeStepType::System,
+                                            OutputProcessor::StoreType::Average,
+                                            waterCoil.Name);
                     }
+                } else {
+                    ShowSevereError(
+                        state,
+                        format("{} = \"{}\" invalid {} = \"{}\".", cFaultCurrentObject, cAlphaArgs(1), cAlphaFieldNames(2), cAlphaArgs(2)));
+                    ShowContinueError(
+                        state, R"(Coil was found but it is not one of the supported types ("Coil:Cooling:Water" or "Coil:Heating:Water").)");
+                    state.dataFaultsMgr->ErrorsFound = true;
                 }
             }
         }
-
+        
         // read faults input: Fault_type 0 to 4, which are related with economizer sensors
         for (int j = 0, i = 0; i <= 4; ++i) {
             cFaultCurrentObject = cFaults(i); // fault object string
@@ -2001,21 +1967,15 @@ namespace FaultsManager {
         return ((deltaPressCal > 0.95 * fan->deltaPress) && (deltaPressCal < 1.05 * fan->deltaPress));
     }
 
-    void SetFaultyCoilSATSensor(
-        EnergyPlusData &state, std::string const &CompType, std::string_view CompName, bool &FaultyCoilSATFlag, int &FaultyCoilSATIndex)
+    int GetFaultyCoilSATIndex(EnergyPlusData &state, std::string const &coilName)
     {
-
-        FaultyCoilSATFlag = false;
-        FaultyCoilSATIndex = 0;
-        if (state.dataFaultsMgr->NumFaultyCoilSATSensor == 0) return;
         for (int jFault_CoilSAT = 1; jFault_CoilSAT <= state.dataFaultsMgr->NumFaultyCoilSATSensor; ++jFault_CoilSAT) {
-            if (Util::SameString(state.dataFaultsMgr->FaultsCoilSATSensor(jFault_CoilSAT).CoilType, CompType) &&
-                Util::SameString(state.dataFaultsMgr->FaultsCoilSATSensor(jFault_CoilSAT).CoilName, CompName)) {
-                FaultyCoilSATFlag = true;
-                FaultyCoilSATIndex = jFault_CoilSAT;
-                break;
+            if (Util::SameString(state.dataFaultsMgr->FaultsCoilSATSensor(jFault_CoilSAT).CoilName, coilName)) {
+                return jFault_CoilSAT;
             }
         }
+
+        return 0;
     }
 
 } // namespace FaultsManager
diff --git a/src/EnergyPlus/FaultsManager.hh b/src/EnergyPlus/FaultsManager.hh
index f57fde3e5cf..ad5e5fbc500 100644
--- a/src/EnergyPlus/FaultsManager.hh
+++ b/src/EnergyPlus/FaultsManager.hh
@@ -211,9 +211,9 @@ namespace FaultsManager {
     struct FaultPropertiesFoulingCoil : public FaultProperties // Class for FaultModel:Fouling:Coil
     {
         // Members
-        std::string FouledCoilName;                   // The fouled coil name
-        DataPlant::PlantEquipmentType FouledCoilType; // Type of coil that's fouled
-        int FouledCoilNum;             // The "FouledUARated" implies having to use the Coil's UA, which could be autosized, so have to use this index
+        std::string CoilName;                   // The fouled coil name
+        DataPlant::PlantEquipmentType coilPlantType = DataPlant::PlantEquipmentType::Invalid; // Type of coil that's fouled
+        int CoilNum = 0;             // The "FouledUARated" implies having to use the Coil's UA, which could be autosized, so have to use this index
         FouledCoil FoulingInputMethod; // Coil fouling input method
         Real64 UAFouled;               // Fouling coil UA under rating conditions
         Real64 Rfw;                    // Water side fouling factor
@@ -223,7 +223,7 @@ namespace FaultsManager {
 
         // Default Constructor
         FaultPropertiesFoulingCoil()
-            : FouledCoilName(""), FouledCoilType(DataPlant::PlantEquipmentType::Invalid), FouledCoilNum(0), FoulingInputMethod(FouledCoil::Invalid),
+            : CoilName(""), FoulingInputMethod(FouledCoil::Invalid),
               UAFouled(0.0), Rfw(0.0), Rfa(0.0), Aout(0.0), Aratio(0.0)
         {
         }
@@ -260,12 +260,15 @@ namespace FaultsManager {
     struct FaultPropertiesCoilSAT : public FaultProperties // Class for FaultModel:TemperatureSensorOffset:CoilSupplyAir
     {
         // Members
-        std::string CoilType;                // Coil type
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;                // Coil type
         std::string CoilName;                // Coil name
+        int CoilNum = 0;
+        
         std::string WaterCoilControllerName; // Water coil controller name
+        int ControllerNum = 0;
 
         // Default Constructor
-        FaultPropertiesCoilSAT() : CoilType(""), CoilName(""), WaterCoilControllerName("")
+        FaultPropertiesCoilSAT() : CoilName(""), WaterCoilControllerName("")
         {
         }
     };
@@ -377,8 +380,7 @@ namespace FaultsManager {
 
     void CheckAndReadFaults(EnergyPlusData &state);
 
-    void SetFaultyCoilSATSensor(
-        EnergyPlusData &state, std::string const &CompType, std::string_view CompName, bool &FaultyCoilSATFlag, int &FaultyCoilSATIndex);
+    int GetFaultyCoilSATIndex(EnergyPlusData &state, std::string const &coilName);
 
 } // namespace FaultsManager
 
diff --git a/src/EnergyPlus/FluidProperties.cc b/src/EnergyPlus/FluidProperties.cc
index 3951017a532..903482b92ca 100644
--- a/src/EnergyPlus/FluidProperties.cc
+++ b/src/EnergyPlus/FluidProperties.cc
@@ -1020,6 +1020,7 @@ namespace Fluid {
                                  format(R"(No Saturated Fluid Enthalpy found. Need properties with {}="Enthalpy" and {}="Fluid".)",
                                         cAlphaFields(2),
                                         cAlphaFields(3)));
+
                 ErrorsFound = true;
             }
 
@@ -1038,15 +1039,17 @@ namespace Fluid {
                                  format(R"(No Saturated Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="Fluid".)",
                                         cAlphaFields(2),
                                         cAlphaFields(3)));
+
                 ErrorsFound = true;
             }
 
             if (refrig->CpfgValues.size() == 0) {
-                ShowSevereCustom(state,
-                                 eoh,
-                                 format(R"(No Saturated Gas/Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="FluidGas".)",
-                                        cAlphaFields(2),
-                                        cAlphaFields(3)));
+                ShowSevereCustom(
+                    state,
+                    eoh,
+                    format(R"(No Saturated Gas/Fluid Specific Heat found. Need properties with {}="SpecificHeat" and {}="FluidGas".)",
+                           cAlphaFields(2),
+                           cAlphaFields(3)));
                 ErrorsFound = true;
             }
 
diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc
index 0827aaf30d8..d19da6c1e91 100644
--- a/src/EnergyPlus/Furnaces.cc
+++ b/src/EnergyPlus/Furnaces.cc
@@ -212,7 +212,7 @@ namespace Furnaces {
 
         // Find the correct Furnace
         if (CompIndex == 0) {
-            FurnaceNum = Util::FindItemInList(FurnaceName, state.dataFurnaces->Furnace);
+            FurnaceNum = Util::FindItemInList(FurnaceName, state.dataFurnaces->Furnaces);
             if (FurnaceNum == 0) {
                 ShowFatalError(state, format("SimFurnace: Unit not found={}", FurnaceName));
             }
@@ -227,12 +227,12 @@ namespace Furnaces {
                                       FurnaceName));
             }
             if (state.dataFurnaces->CheckEquipName(FurnaceNum)) {
-                if (FurnaceName != state.dataFurnaces->Furnace(FurnaceNum).Name) {
+                if (FurnaceName != state.dataFurnaces->Furnaces(FurnaceNum).Name) {
                     ShowFatalError(state,
                                    format("SimFurnace: Invalid CompIndex passed={}, Unit name={}, stored Unit Name for that index={}",
                                           FurnaceNum,
                                           FurnaceName,
-                                          state.dataFurnaces->Furnace(FurnaceNum).Name));
+                                          state.dataFurnaces->Furnaces(FurnaceNum).Name));
                 }
                 state.dataFurnaces->CheckEquipName(FurnaceNum) = false;
             }
@@ -243,12 +243,12 @@ namespace Furnaces {
         // here we need to deal with sequenced zone equip sensible load in control zone
         Real64 ZoneLoad = 0.0;
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-        auto &zoneSysEnergyDemand = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum);
-        if (thisFurnace.ZoneSequenceCoolingNum > 0 && thisFurnace.ZoneSequenceHeatingNum > 0) {
-            Real64 ZoneLoadToCoolSPSequenced = zoneSysEnergyDemand.SequencedOutputRequiredToCoolingSP(thisFurnace.ZoneSequenceCoolingNum);
-            Real64 ZoneLoadToHeatSPSequenced = zoneSysEnergyDemand.SequencedOutputRequiredToHeatingSP(thisFurnace.ZoneSequenceHeatingNum);
-            auto const &tempControlType = state.dataHeatBalFanSys->TempControlType(thisFurnace.ControlZoneNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+        auto &zoneSysEnergyDemand = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum);
+        if (furnace.ZoneSequenceCoolingNum > 0 && furnace.ZoneSequenceHeatingNum > 0) {
+            Real64 ZoneLoadToCoolSPSequenced = zoneSysEnergyDemand.SequencedOutputRequiredToCoolingSP(furnace.ZoneSequenceCoolingNum);
+            Real64 ZoneLoadToHeatSPSequenced = zoneSysEnergyDemand.SequencedOutputRequiredToHeatingSP(furnace.ZoneSequenceHeatingNum);
+            auto const &tempControlType = state.dataHeatBalFanSys->TempControlType(furnace.ControlZoneNum);
             if (ZoneLoadToHeatSPSequenced > 0.0 && ZoneLoadToCoolSPSequenced > 0.0 && tempControlType != HVAC::SetptType::SingleCool) {
                 ZoneLoad = ZoneLoadToHeatSPSequenced;
             } else if (ZoneLoadToHeatSPSequenced > 0.0 && ZoneLoadToCoolSPSequenced > 0.0 && tempControlType == HVAC::SetptType::SingleCool) {
@@ -260,66 +260,66 @@ namespace Furnaces {
             } else if (ZoneLoadToHeatSPSequenced <= 0.0 && ZoneLoadToCoolSPSequenced >= 0.0) {
                 ZoneLoad = 0.0;
             }
-            MoistureLoad = state.dataZoneEnergyDemand->ZoneSysMoistureDemand(thisFurnace.ControlZoneNum)
-                               .SequencedOutputRequiredToDehumidSP(thisFurnace.ZoneSequenceCoolingNum);
+            MoistureLoad = state.dataZoneEnergyDemand->ZoneSysMoistureDemand(furnace.ControlZoneNum)
+                               .SequencedOutputRequiredToDehumidSP(furnace.ZoneSequenceCoolingNum);
         } else {
             ZoneLoad = zoneSysEnergyDemand.RemainingOutputRequired;
-            MoistureLoad = state.dataZoneEnergyDemand->ZoneSysMoistureDemand(thisFurnace.ControlZoneNum).OutputRequiredToDehumidifyingSP;
+            MoistureLoad = state.dataZoneEnergyDemand->ZoneSysMoistureDemand(furnace.ControlZoneNum).OutputRequiredToDehumidifyingSP;
         }
 
         // H2OHtOfVap
-        MoistureLoad *= Psychrometrics::PsyHfgAirFnWTdb(state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).HumRat,
-                                                        state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).Temp);
+        MoistureLoad *= Psychrometrics::PsyHfgAirFnWTdb(state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).HumRat,
+                                                        state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).Temp);
 
         // Initialize Furnace Flows
         InitFurnace(state, FurnaceNum, AirLoopNum, OnOffAirFlowRatio, fanOp, ZoneLoad, MoistureLoad, FirstHVACIteration);
 
-        int FurnaceInletNode = thisFurnace.FurnaceInletNodeNum;
+        int FurnaceInletNode = furnace.FurnaceInletNode;
 
         // MassFlowRateMaxAvail issues are impeding non-VAV air loop equipment by limiting air flow
         // temporarily open up flow limits while simulating, and then set this same value at the INLET after this parent has simulated
         Real64 TempMassFlowRateMaxAvail = state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRateMaxAvail;
-        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRateMaxAvail = thisFurnace.DesignMassFlowRate;
+        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRateMaxAvail = furnace.DesignMassFlowRate;
 
         Real64 FurnaceSavMdot = state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate;
         HVAC::CompressorOp compressorOp = HVAC::CompressorOp::On;
         state.dataFurnaces->CoolHeatPLRRat = 1.0;
 
         // Simulate correct system type (1 of 4 choices)
-        switch (thisFurnace.type) {
+        switch (furnace.type) {
             // Simulate HeatOnly systems:
         case HVAC::UnitarySysType::Furnace_HeatOnly:
         case HVAC::UnitarySysType::Unitary_HeatOnly: {
             // Update the furnace flow rates
             CalcNewZoneHeatOnlyFlowRates(state, FurnaceNum, FirstHVACIteration, ZoneLoad, HeatCoilLoad, OnOffAirFlowRatio);
 
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
                 // simulate fan
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
 
             // simulate furnace heating coil
             SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
             CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
 
-            if (thisFurnace.fanPlace == HVAC::FanPlace::DrawThru) {
+            if (furnace.fanPlace == HVAC::FanPlace::DrawThru) {
                 // simulate fan
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
         } break;
             // Simulate HeatCool systems:
         case HVAC::UnitarySysType::Furnace_HeatCool:
         case HVAC::UnitarySysType::Unitary_HeatCool: {
-            if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                 // variable speed cooling coil
                 HeatCoilLoad = 0.0;
-                if (thisFurnace.bIsIHP)
-                    state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).ControlledZoneTemp =
-                        state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).Temp;
+                if (furnace.isIHP)
+                    state.dataIntegratedHP->IntegratedHeatPumps(furnace.CoolCoilNum).ControlledZoneTemp =
+                        state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).Temp;
                 SimVariableSpeedHP(state, FurnaceNum, FirstHVACIteration, AirLoopNum, ZoneLoad, MoistureLoad, OnOffAirFlowRatio);
             } else {
                 // calculate the system flow rate
-                if (!FirstHVACIteration && thisFurnace.fanOp == HVAC::FanOp::Cycling && state.dataFurnaces->CoolingLoad &&
+                if (!FirstHVACIteration && furnace.fanOp == HVAC::FanOp::Cycling && state.dataFurnaces->CoolingLoad &&
                     state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive) {
                     // for cycling fan, cooling load, check whether furnace can meet load with compressor off
                     compressorOp = HVAC::CompressorOp::Off;
@@ -333,8 +333,8 @@ namespace Furnaces {
                                                  ReheatCoilLoad,
                                                  OnOffAirFlowRatio,
                                                  HXUnitOn);
-                    if (thisFurnace.CoolPartLoadRatio >= 1.0 || thisFurnace.HeatPartLoadRatio >= 1.0 ||
-                        (thisFurnace.CoolPartLoadRatio <= 0.0 && thisFurnace.HeatPartLoadRatio <= 0.0)) {
+                    if (furnace.CoolPartLoadRatio >= 1.0 || furnace.HeatPartLoadRatio >= 1.0 ||
+                        (furnace.CoolPartLoadRatio <= 0.0 && furnace.HeatPartLoadRatio <= 0.0)) {
                         // compressor on (reset inlet air mass flow rate to starting value)
                         state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = FurnaceSavMdot;
                         compressorOp = HVAC::CompressorOp::On;
@@ -363,54 +363,52 @@ namespace Furnaces {
                                                  HXUnitOn);
                 }
 
-                if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
                     // simulate fan
-                    state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                    state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 }
 
-                if (!thisFurnace.CoolingCoilUpstream) {
+                if (!furnace.CoolCoilUpstream) {
                     // simulate furnace heating coil
                     SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
                     CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
                 }
 
                 // simulate furnace DX cooling coil
-                if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                        BlankString,
-                                                                        FirstHVACIteration,
-                                                                        compressorOp,
-                                                                        thisFurnace.CoolPartLoadRatio,
-                                                                        thisFurnace.CoolingCoilIndex,
-                                                                        fanOp,
-                                                                        HXUnitOn,
-                                                                        OnOffAirFlowRatio,
-                                                                        state.dataFurnaces->EconomizerFlag);
+                if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                           furnace.CoolCoilNum,
+                                                           FirstHVACIteration,
+                                                           compressorOp,
+                                                           furnace.CoolPartLoadRatio,
+                                                           fanOp,
+                                                           HXUnitOn,
+                                                           OnOffAirFlowRatio,
+                                                           state.dataFurnaces->EconomizerFlag);
                 } else {
                     DXCoils::SimDXCoil(state,
-                                       BlankString,
+                                       furnace.CoolCoilNum,
                                        compressorOp,
                                        FirstHVACIteration,
-                                       thisFurnace.CoolingCoilIndex,
                                        fanOp,
-                                       thisFurnace.CoolPartLoadRatio,
+                                       furnace.CoolPartLoadRatio,
                                        OnOffAirFlowRatio,
                                        state.dataFurnaces->CoolHeatPLRRat);
                 }
 
-                if (thisFurnace.CoolingCoilUpstream) {
+                if (furnace.CoolCoilUpstream) {
                     // simulate furnace heating coil
                     SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
                     CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
                 }
 
-                if (thisFurnace.fanPlace == HVAC::FanPlace::DrawThru) {
+                if (furnace.fanPlace == HVAC::FanPlace::DrawThru) {
                     // simulate fan
-                    state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                    state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 }
 
                 // Simulate furnace reheat coil if a humidistat is used or if the reheat coil is present
-                if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat || thisFurnace.SuppHeatCoilIndex > 0) {
+                if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat || furnace.SuppCoilNum > 0) {
                     SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
                     CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual);
                 }
@@ -418,21 +416,21 @@ namespace Furnaces {
         } break;
             // Simulate air-to-air heat pumps:
         case HVAC::UnitarySysType::Unitary_HeatPump_AirToAir: {
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 // variable speed heat pump
                 HeatCoilLoad = 0.0;
-                if (thisFurnace.bIsIHP) {
-                    auto &integratedHP = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex);
-                    integratedHP.ControlledZoneTemp = state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).Temp;
-                    integratedHP.IDFanID = thisFurnace.FanIndex; // why do this every time?
+                if (furnace.isIHP) {
+                    auto &integratedHP = state.dataIntegratedHP->IntegratedHeatPumps(furnace.CoolCoilNum);
+                    integratedHP.ControlledZoneTemp = state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).Temp;
+                    integratedHP.IDFanID = furnace.FanIndex; // why do this every time?
                     integratedHP.IDFanName = BlankString;
-                    integratedHP.fanPlace = thisFurnace.fanPlace;
+                    integratedHP.fanPlace = furnace.fanPlace;
                 }
 
                 SimVariableSpeedHP(state, FurnaceNum, FirstHVACIteration, AirLoopNum, ZoneLoad, MoistureLoad, OnOffAirFlowRatio);
             } else {
                 // Update the furnace flow rates
-                if (!FirstHVACIteration && thisFurnace.fanOp == HVAC::FanOp::Cycling && state.dataFurnaces->CoolingLoad &&
+                if (!FirstHVACIteration && furnace.fanOp == HVAC::FanOp::Cycling && state.dataFurnaces->CoolingLoad &&
                     state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive) {
                     // for cycling fan, cooling load, check whether furnace can meet load with compressor off
                     compressorOp = HVAC::CompressorOp::Off;
@@ -446,8 +444,8 @@ namespace Furnaces {
                                                  ReheatCoilLoad,
                                                  OnOffAirFlowRatio,
                                                  HXUnitOn);
-                    if (thisFurnace.CoolPartLoadRatio >= 1.0 || thisFurnace.HeatPartLoadRatio >= 1.0 ||
-                        (thisFurnace.CoolPartLoadRatio <= 0.0 && thisFurnace.HeatPartLoadRatio <= 0.0)) {
+                    if (furnace.CoolPartLoadRatio >= 1.0 || furnace.HeatPartLoadRatio >= 1.0 ||
+                        (furnace.CoolPartLoadRatio <= 0.0 && furnace.HeatPartLoadRatio <= 0.0)) {
                         // compressor on (reset inlet air mass flow rate to starting value)
                         compressorOp = HVAC::CompressorOp::On;
                         state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = FurnaceSavMdot;
@@ -476,17 +474,17 @@ namespace Furnaces {
                                                  HXUnitOn);
                 }
 
-                if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                    state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                    state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 }
 
-                if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
+                if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
                                                                         BlankString,
                                                                         FirstHVACIteration,
                                                                         compressorOp,
-                                                                        thisFurnace.CoolPartLoadRatio,
-                                                                        thisFurnace.CoolingCoilIndex,
+                                                                        furnace.CoolPartLoadRatio,
+                                                                        furnace.CoolCoilNum,
                                                                         fanOp,
                                                                         HXUnitOn,
                                                                         OnOffAirFlowRatio,
@@ -496,26 +494,26 @@ namespace Furnaces {
                                        BlankString,
                                        compressorOp,
                                        FirstHVACIteration,
-                                       thisFurnace.CoolingCoilIndex,
+                                       furnace.CoolCoilNum,
                                        fanOp,
-                                       thisFurnace.CoolPartLoadRatio,
+                                       furnace.CoolPartLoadRatio,
                                        OnOffAirFlowRatio);
                 }
                 DXCoils::SimDXCoil(state,
                                    BlankString,
                                    compressorOp,
                                    FirstHVACIteration,
-                                   thisFurnace.HeatingCoilIndex,
+                                   furnace.HeatCoilNum,
                                    fanOp,
-                                   thisFurnace.HeatPartLoadRatio,
+                                   furnace.HeatPartLoadRatio,
                                    OnOffAirFlowRatio);
-                if (thisFurnace.fanPlace == HVAC::FanPlace::DrawThru) {
-                    state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                if (furnace.fanPlace == HVAC::FanPlace::DrawThru) {
+                    state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 }
 
                 // Simulate furnace reheat coil if a humidistat is present, the dehumidification type of coolreheat and
                 // reheat coil load exists
-                if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
+                if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
                     SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
                     CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual);
                 } else {
@@ -526,11 +524,11 @@ namespace Furnaces {
         } break;
         // Simulate water-to-air systems:
         case HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir: {
-            if (thisFurnace.WatertoAirHPType == WAHPCoilType::Simple) {
+            if (furnace.WatertoAirHPType == WAHPCoilType::Simple) {
                 // Update the furnace flow rates
                 //   When CompressorOp logic is added to the child cooling coil (COIL:WaterToAirHP:EquationFit:Cooling), then this logic
                 //   needs to be reinstated... to align with Unitary/Furnace HeatCool and Unitary Air-to-Air Heat Pump (see above).
-                if (!FirstHVACIteration && thisFurnace.fanOp == HVAC::FanOp::Cycling && state.dataFurnaces->CoolingLoad &&
+                if (!FirstHVACIteration && furnace.fanOp == HVAC::FanOp::Cycling && state.dataFurnaces->CoolingLoad &&
                     state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive) {
                     // for cycling fan, cooling load, check whether furnace can meet load with compressor off
                     compressorOp = HVAC::CompressorOp::Off;
@@ -544,8 +542,8 @@ namespace Furnaces {
                                                  ReheatCoilLoad,
                                                  OnOffAirFlowRatio,
                                                  HXUnitOn);
-                    if (thisFurnace.CoolPartLoadRatio >= 1.0 || thisFurnace.HeatPartLoadRatio >= 1.0 ||
-                        (thisFurnace.CoolPartLoadRatio <= 0.0 && thisFurnace.HeatPartLoadRatio <= 0.0)) {
+                    if (furnace.CoolPartLoadRatio >= 1.0 || furnace.HeatPartLoadRatio >= 1.0 ||
+                        (furnace.CoolPartLoadRatio <= 0.0 && furnace.HeatPartLoadRatio <= 0.0)) {
                         // compressor on (reset inlet air mass flow rate to starting value)
                         compressorOp = HVAC::CompressorOp::On;
                         state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = FurnaceSavMdot;
@@ -573,53 +571,53 @@ namespace Furnaces {
                                                  OnOffAirFlowRatio,
                                                  HXUnitOn);
                 }
-                if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                    state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                    state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 }
 
                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
                                                                 BlankString,
-                                                                thisFurnace.CoolingCoilIndex,
-                                                                thisFurnace.CoolingCoilSensDemand,
-                                                                thisFurnace.CoolingCoilLatentDemand,
-                                                                thisFurnace.fanOp,
+                                                                furnace.CoolCoilNum,
+                                                                furnace.CoolingCoilSensDemand,
+                                                                furnace.CoolingCoilLatentDemand,
+                                                                furnace.fanOp,
                                                                 compressorOp,
-                                                                thisFurnace.CoolPartLoadRatio,
+                                                                furnace.CoolPartLoadRatio,
                                                                 FirstHVACIteration);
                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
                                                                 BlankString,
-                                                                thisFurnace.HeatingCoilIndex,
-                                                                thisFurnace.HeatingCoilSensDemand,
+                                                                furnace.HeatCoilNum,
+                                                                furnace.HeatingCoilSensDemand,
                                                                 Dummy,
-                                                                thisFurnace.fanOp,
+                                                                furnace.fanOp,
                                                                 compressorOp,
-                                                                thisFurnace.HeatPartLoadRatio,
+                                                                furnace.HeatPartLoadRatio,
                                                                 FirstHVACIteration);
 
-                if (thisFurnace.fanPlace == HVAC::FanPlace::DrawThru) {
-                    state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                if (furnace.fanPlace == HVAC::FanPlace::DrawThru) {
+                    state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 }
-                if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
+                if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
                     SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
                     CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual);
                 } else {
                     SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
                     CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
                 }
-            } else if (thisFurnace.WatertoAirHPType == WAHPCoilType::ParEst) {
+            } else if (furnace.WatertoAirHPType == WAHPCoilType::ParEst) {
 
                 // simulate the heat pump
                 HeatCoilLoad = 0.0;
                 CalcWaterToAirHeatPump(state, FurnaceNum, FirstHVACIteration, compressorOp, ZoneLoad, MoistureLoad);
-            } else if (thisFurnace.WatertoAirHPType == WAHPCoilType::VarSpeedEquationFit) {
+            } else if (furnace.WatertoAirHPType == WAHPCoilType::VarSpeedEquationFit) {
                 // simulate the heat pump
                 HeatCoilLoad = 0.0;
-                if (thisFurnace.bIsIHP)
-                    state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).ControlledZoneTemp =
-                        state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).Temp;
+                if (furnace.isIHP)
+                    state.dataIntegratedHP->IntegratedHeatPumps(furnace.CoolCoilNum).ControlledZoneTemp =
+                        state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).Temp;
                 SimVariableSpeedHP(state, FurnaceNum, FirstHVACIteration, AirLoopNum, ZoneLoad, MoistureLoad, OnOffAirFlowRatio);
 
-            } else if (thisFurnace.WatertoAirHPType == WAHPCoilType::VarSpeedLookupTable) {
+            } else if (furnace.WatertoAirHPType == WAHPCoilType::VarSpeedLookupTable) {
                 HeatCoilLoad = 0.0; // Added: Used below
             } else {
                 assert(false); //? If all possible states covered by if conditions change to HeatCoilLoad = 0.0;
@@ -633,21 +631,21 @@ namespace Furnaces {
 
         // set the econo lockout flags
         auto &airLoopControlInfo = state.dataAirLoop->AirLoopControlInfo(AirLoopNum);
-        if (thisFurnace.CompPartLoadRatio > 0.0 && airLoopControlInfo.CanLockoutEconoWithCompressor) {
+        if (furnace.CompPartLoadRatio > 0.0 && airLoopControlInfo.CanLockoutEconoWithCompressor) {
             airLoopControlInfo.ReqstEconoLockoutWithCompressor = true;
         } else {
             airLoopControlInfo.ReqstEconoLockoutWithCompressor = false;
         }
 
-        if ((HeatCoilLoad > 0.0 || thisFurnace.HeatPartLoadRatio > 0.0) &&
+        if ((HeatCoilLoad > 0.0 || furnace.HeatPartLoadRatio > 0.0) &&
             (airLoopControlInfo.CanLockoutEconoWithCompressor || airLoopControlInfo.CanLockoutEconoWithHeating)) {
             airLoopControlInfo.ReqstEconoLockoutWithHeating = true;
         } else {
             airLoopControlInfo.ReqstEconoLockoutWithHeating = false;
         }
 
-        if (thisFurnace.fanOp == HVAC::FanOp::Cycling) {
-            state.dataAirLoop->AirLoopFlow(AirLoopNum).FanPLR = thisFurnace.FanPartLoadRatio;
+        if (furnace.fanOp == HVAC::FanOp::Cycling) {
+            state.dataAirLoop->AirLoopFlow(AirLoopNum).FanPLR = furnace.FanPartLoadRatio;
         } else {
             state.dataAirLoop->AirLoopFlow(AirLoopNum).FanPLR = 1.0; // 1 means constant fan does not cycle.
         }
@@ -712,31 +710,13 @@ namespace Furnaces {
         int TstatZoneNum;              // Used to determine if control zone has a thermostat object
         int HStatZoneNum;              // Used to determine if control zone has a humidistat object
         bool errFlag;                  // Mining function error flag
-        int FanInletNode;              // Used for node checking warning messages
-        int FanOutletNode;             // Used for node checking warning messages
-        int CoolingCoilInletNode;      // Used for node checking warning messages
-        int CoolingCoilOutletNode;     // Used for node checking warning messages
-        int HeatingCoilInletNode;      // Used for node checking warning messages
-        int HeatingCoilOutletNode;     // Used for node checking warning messages
-        int SupHeatCoilInletNode;      // Used for node checking warning messages
-        int SupHeatCoilOutletNode;     // Used for node checking warning messages
-        std::string CoolingCoilType;   // Used in mining function CALLS
-        std::string CoolingCoilName;   // Used in mining function CALLS
-        std::string HeatingCoilType;   // Used in mining function CALLS
-        std::string HeatingCoilName;   // Used in mining function CALLS
-        std::string ReheatingCoilType; // Used in mining function CALLS
-        std::string ReheatingCoilName; // Used in mining function CALLS
-        std::string SuppHeatCoilType;  // Used in mining function CALLS
-        std::string SuppHeatCoilName;  // Used in mining function CALLS
         std::string FanName;           // Used in mining function CALLS
         bool PrintMessage;             // Used in mining function CALLS
-        int HeatingCoilPLFCurveIndex;  // index of heating coil PLF curve
-        Real64 SteamDensity;           // density of steam at 100C
-        int DXCoilIndex;               // Index to DX coil in HXAssited object
-        std::string IHPCoilName;       // IHP cooling coil name
         auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
         DataLoopNode::ConnectionObjectType currentModuleObjectType;
 
+        auto &s_node = state.dataLoopNodes;
+          
         state.dataFurnaces->GetFurnaceInputFlag = false;
         int MaxNumbers = 0;
         int MaxAlphas = 0;
@@ -787,7 +767,7 @@ namespace Furnaces {
         state.dataFurnaces->NumFurnaces = NumHeatOnly + NumHeatCool + NumUnitaryHeatOnly + NumUnitaryHeatCool + NumHeatPump + NumWaterToAirHeatPump;
 
         if (state.dataFurnaces->NumFurnaces > 0) {
-            state.dataFurnaces->Furnace.allocate(state.dataFurnaces->NumFurnaces);
+            state.dataFurnaces->Furnaces.allocate(state.dataFurnaces->NumFurnaces);
             state.dataFurnaces->UniqueFurnaceNames.reserve(state.dataFurnaces->NumFurnaces);
         }
         state.dataFurnaces->CheckEquipName.dimension(state.dataFurnaces->NumFurnaces, true);
@@ -797,33 +777,24 @@ namespace Furnaces {
         // Get the data for the HeatOnly Furnace
         for (int HeatOnlyNum = 1; HeatOnlyNum <= NumHeatOnly + NumUnitaryHeatOnly; ++HeatOnlyNum) {
 
-            FanInletNode = 0;
-            FanOutletNode = 0;
-            HeatingCoilInletNode = 0;
-            HeatingCoilOutletNode = 0;
-            CoolingCoilType = ' ';
-            CoolingCoilName = ' ';
-            HeatingCoilType = ' ';
-            HeatingCoilName = ' ';
-
             FurnaceNum = HeatOnlyNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
             //       Furnace and UnitarySystem objects are both read in here.
             //       Will still have 2 differently named objects for the user, but read in with 1 DO loop.
             if (HeatOnlyNum <= NumHeatOnly) {
                 CurrentModuleObject = "AirLoopHVAC:Unitary:Furnace:HeatOnly";
                 currentModuleObjectType = DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryFurnaceHeatOnly;
-                thisFurnace.type = HVAC::UnitarySysType::Furnace_HeatOnly;
+                furnace.type = HVAC::UnitarySysType::Furnace_HeatOnly;
                 GetObjectNum = HeatOnlyNum;
             } else {
                 CurrentModuleObject = "AirLoopHVAC:UnitaryHeatOnly";
                 currentModuleObjectType = DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatOnly;
-                thisFurnace.type = HVAC::UnitarySysType::Unitary_HeatOnly;
+                furnace.type = HVAC::UnitarySysType::Unitary_HeatOnly;
                 GetObjectNum = HeatOnlyNum - NumHeatOnly;
             }
 
-            thisFurnace.iterationMode.allocate(3);
+            furnace.iterationMode.allocate(3);
 
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      CurrentModuleObject,
@@ -841,17 +812,17 @@ namespace Furnaces {
             GlobalNames::VerifyUniqueInterObjectName(
                 state, state.dataFurnaces->UniqueFurnaceNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
 
-            thisFurnace.Name = Alphas(1);
-            ErrorObjectHeader eoh{routineName, cAlphaFields(1), thisFurnace.Name};
+            furnace.Name = Alphas(1);
+            ErrorObjectHeader eoh{routineName, cAlphaFields(1), furnace.Name};
 
             if (lAlphaBlanks(2)) {
-                thisFurnace.availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((thisFurnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                furnace.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((furnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
                 ErrorsFound = true;
             }
 
-            thisFurnace.FurnaceInletNodeNum = NodeInputManager::GetOnlySingleNode(state,
+            furnace.FurnaceInletNode = NodeInputManager::GetOnlySingleNode(state,
                                                                                   Alphas(3),
                                                                                   ErrorsFound,
                                                                                   currentModuleObjectType,
@@ -860,7 +831,7 @@ namespace Furnaces {
                                                                                   DataLoopNode::ConnectionType::Inlet,
                                                                                   NodeInputManager::CompFluidStream::Primary,
                                                                                   DataLoopNode::ObjectIsParent);
-            thisFurnace.FurnaceOutletNodeNum = NodeInputManager::GetOnlySingleNode(state,
+            furnace.FurnaceOutletNode = NodeInputManager::GetOnlySingleNode(state,
                                                                                    Alphas(4),
                                                                                    ErrorsFound,
                                                                                    currentModuleObjectType,
@@ -873,28 +844,28 @@ namespace Furnaces {
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
             if (lAlphaBlanks(5)) {
-                thisFurnace.fanOp = HVAC::FanOp::Cycling;
-            } else if ((thisFurnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(5))) == nullptr) {
+                furnace.fanOp = HVAC::FanOp::Cycling;
+            } else if ((furnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(5))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(5), Alphas(5));
                 ErrorsFound = true;
             }
 
             // Get the Controlling Zone or Location of the Furnace Thermostat
 
-            thisFurnace.ControlZoneNum = Util::FindItemInList(Alphas(6), state.dataHeatBal->Zone);
-            if (thisFurnace.ControlZoneNum == 0) {
+            furnace.ControlZoneNum = Util::FindItemInList(Alphas(6), state.dataHeatBal->Zone);
+            if (furnace.ControlZoneNum == 0) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(6), Alphas(6)));
                 ErrorsFound = true;
             }
 
             // Get the node number for the zone with the thermostat
-            if (thisFurnace.ControlZoneNum > 0) {
+            if (furnace.ControlZoneNum > 0) {
                 AirNodeFound = false;
                 AirLoopFound = false;
-                int ControlledZoneNum = thisFurnace.ControlZoneNum;
+                int ControlledZoneNum = furnace.ControlZoneNum;
                 //             Find the controlled zone number for the specified thermostat location
-                thisFurnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
+                furnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
                 //             Determine if furnace is on air loop served by the thermostat location specified
                 for (int zoneInNode = 1; zoneInNode <= state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).NumInletNodes; ++zoneInNode) {
                     int AirLoopNumber = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNodeAirLoopNum(zoneInNode);
@@ -904,23 +875,23 @@ namespace Furnaces {
                                  CompNum <= state.dataAirSystemsData->PrimaryAirSystems(AirLoopNumber).Branch(BranchNum).TotalComponents;
                                  ++CompNum) {
                                 if (!Util::SameString(state.dataAirSystemsData->PrimaryAirSystems(AirLoopNumber).Branch(BranchNum).Comp(CompNum).Name,
-                                                      thisFurnace.Name) ||
+                                                      furnace.Name) ||
                                     !Util::SameString(
                                         state.dataAirSystemsData->PrimaryAirSystems(AirLoopNumber).Branch(BranchNum).Comp(CompNum).TypeOf,
                                         CurrentModuleObject))
                                     continue;
                                 AirLoopFound = true;
-                                thisFurnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
+                                furnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
                                 break;
                             }
                             if (AirLoopFound) break;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumTempControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumComfortControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                     }
@@ -946,26 +917,26 @@ namespace Furnaces {
             FanName = Alphas(8);
             errFlag = false;
 
-            thisFurnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(7)));
-            if (thisFurnace.fanType != HVAC::FanType::OnOff && thisFurnace.fanType != HVAC::FanType::Constant) {
+            furnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(7)));
+            if (furnace.fanType != HVAC::FanType::OnOff && furnace.fanType != HVAC::FanType::Constant) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(7), Alphas(7)));
                 ErrorsFound = true;
 
-            } else if ((thisFurnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
+            } else if ((furnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(8), FanName);
                 ErrorsFound = true;
 
             } else {
-                auto *fan = state.dataFans->fans(thisFurnace.FanIndex);
-                thisFurnace.ActualFanVolFlowRate = fan->maxAirFlowRate;
-                FanInletNode = fan->inletNodeNum;
-                FanOutletNode = fan->outletNodeNum;
-                thisFurnace.fanAvailSched = fan->availSched;
+                auto *fan = state.dataFans->fans(furnace.FanIndex);
+                furnace.ActualFanVolFlowRate = fan->maxAirFlowRate;
+                furnace.FanInletNode = fan->inletNodeNum;
+                furnace.FanOutletNode = fan->outletNodeNum;
+                furnace.fanAvailSched = fan->availSched;
 
                 // Check fan's schedule for cycling fan operation if constant volume fan is used
-                if (thisFurnace.fanOpModeSched != nullptr && thisFurnace.fanType == HVAC::FanType::Constant) {
-                    if (!thisFurnace.fanOpModeSched->checkMinMaxVals(state, Clusive::Ex, 0.0, Clusive::In, 1.0)) {
+                if (furnace.fanOpModeSched != nullptr && furnace.fanType == HVAC::FanType::Constant) {
+                    if (!furnace.fanOpModeSched->checkMinMaxVals(state, Clusive::Ex, 0.0, Clusive::In, 1.0)) {
                         Sched::ShowSevereBadMinMax(
                             state,
                             eoh,
@@ -976,292 +947,169 @@ namespace Furnaces {
                             Clusive::In,
                             1.0,
                             format("For {} = {}, Fan operating mode must be continuous (schedule values > 0)", cAlphaFields(7), Alphas(7)));
+
                         ErrorsFound = true;
                     }
-                } else if (lAlphaBlanks(5) && thisFurnace.fanType != HVAC::FanType::OnOff) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, thisFurnace.Name));
+                } else if (lAlphaBlanks(5) && furnace.fanType != HVAC::FanType::OnOff) {
+                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, furnace.Name));
                     ShowContinueError(state, format("{} = {}", cAlphaFields(7), Alphas(7)));
                     ShowContinueError(state, format("Fan type must be Fan:OnOff when {} = Blank.", cAlphaFields(5)));
                     ErrorsFound = true;
                 }
             }
 
-            thisFurnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(9)));
-            assert(thisFurnace.fanPlace != HVAC::FanPlace::Invalid);
+            furnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(9)));
+            assert(furnace.fanPlace != HVAC::FanPlace::Invalid);
 
             // Get coil data
-            HeatingCoilType = Alphas(10);
-            HeatingCoilName = Alphas(11);
-            thisFurnace.HeatingCoilType = HeatingCoilType;
-            thisFurnace.HeatingCoilName = HeatingCoilName;
-            if (Util::SameString(HeatingCoilType, "Coil:Heating:Fuel") || Util::SameString(HeatingCoilType, "Coil:Heating:Electric")) {
-                errFlag = false;
-                thisFurnace.HeatingCoilType_Num = HeatingCoils::GetHeatingCoilTypeNum(state, HeatingCoilType, HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            furnace.HeatCoilName = Alphas(11);
+            furnace.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(10)));
+            
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                furnace.heatCoilType == HVAC::CoilType::HeatingElectric) {
+
+                // Get index to Heating Coil
+                furnace.HeatCoilNum = HeatingCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), Alphas(11));
                     ErrorsFound = true;
                 } else {
-                    ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-
-                    } else { // mine data from heating coil object
-
-                        // Get index to Heating Coil
-                        errFlag = false;
-                        HeatingCoils::GetCoilIndex(state, HeatingCoilName, thisFurnace.HeatingCoilIndex, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the furnace design capacity
-                        errFlag = false;
-                        thisFurnace.DesignHeatingCapacity = HeatingCoils::GetCoilCapacity(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} ={}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Heating Coil Inlet Node
-                        errFlag = false;
-                        HeatingCoilInletNode = HeatingCoils::GetCoilInletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        thisFurnace.HWCoilAirInletNode = HeatingCoilInletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} ={}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Heating Coil Outlet Node
-                        errFlag = false;
-                        HeatingCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} ={}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
+                    furnace.DesignHeatingCapacity = HeatingCoils::GetCoilCapacity(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
 
-                    } // IF (IsNotOK) THEN
+                    assert(furnace.HeatCoilAirInletNode != 0 && furnace.HeatCoilAirOutletNode != 0);
                 }
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWater) {
 
-            } else if (Util::SameString(HeatingCoilType, "Coil:Heating:Water")) {
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingWater;
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                furnace.HeatCoilNum = WaterCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), Alphas(11));
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    // Get the Heating Coil water Inlet or control Node number
-                    errFlag = false;
-                    thisFurnace.CoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil hot water max volume flow rate
-                    errFlag = false;
-                    thisFurnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil Inlet Node
-                    errFlag = false;
-                    HeatingCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirInletNode = HeatingCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil Outlet Node
-                    errFlag = false;
-                    HeatingCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirOutletNode = HeatingCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // check if user has also used a water coil controller, which they should not do
-                    errFlag = false;
-                    HVACControllers::CheckCoilWaterInletNode(state, thisFurnace.CoilControlNode, errFlag);
+                } else {
+                    furnace.HeatCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, furnace.HeatCoilNum);
+                    furnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
+                    
+                    HVACControllers::CheckCoilWaterInletNode(state, furnace.HeatCoilControlNode, errFlag);
                     if (!errFlag) { // then did find a controller so that is bad
                         ShowSevereError(state,
-                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, thisFurnace.Name));
+                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, furnace.Name));
                         ShowContinueError(state, "Hot water coils are controlled directly by unitary and furnace systems.");
                         ShowContinueError(state, "No water coil controller should be input for the coil.");
                         ErrorsFound = true;
                     }
                 }
 
-            } else if (Util::SameString(HeatingCoilType, "Coil:Heating:Steam")) {
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingSteam;
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                furnace.HeatCoilNum = SteamCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.HeatCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    errFlag = false;
-                    thisFurnace.HeatingCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", HeatingCoilName, errFlag);
-                    if (thisFurnace.HeatingCoilIndex == 0) {
-                        ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(11), HeatingCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil steam inlet node number
-                    errFlag = false;
-                    thisFurnace.CoilControlNode = SteamCoils::GetCoilSteamInletNode(state, "COIL:HEATING:STEAM", HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil steam max volume flow rate
-                    thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, errFlag);
-                    if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) {
-                        SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, getUnitaryHeatOnly);
-                        thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity;
-                    }
-
-                    // Get the Heating Coil Inlet Node
-                    errFlag = false;
-                    HeatingCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisFurnace.HeatingCoilIndex, HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirInletNode = HeatingCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
+                } else {
+                    furnace.HeatCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, furnace.HeatCoilNum);
+                    furnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.HeatCoilNum);
+                    if (furnace.MaxHeatCoilFluidFlow > 0.0) {
+                        furnace.MaxHeatCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, getUnitaryHeatOnly);
                     }
 
-                    // Get the Heating Coil Outlet Node
-                    errFlag = false;
-                    HeatingCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisFurnace.HeatingCoilIndex, HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirOutletNode = HeatingCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
+                    furnace.HeatCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
                 }
-
             } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(11), Alphas(11)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(11), Alphas(11));
                 ErrorsFound = true;
             } // IF (Furnace(FurnaceNum)%HeatingCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
 
             // Add component sets array
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
                 CompSetFanInlet = Alphas(3);
-                CompSetFanOutlet = state.dataLoopNodes->NodeID(FanOutletNode);
-                CompSetHeatInlet = state.dataLoopNodes->NodeID(FanOutletNode);
+                CompSetFanOutlet = s_node->NodeID(furnace.FanOutletNode);
+                CompSetHeatInlet = s_node->NodeID(furnace.FanOutletNode);
                 CompSetHeatOutlet = Alphas(4);
                 // Fan inlet node name must not be the same as the furnace inlet node name
-                if (FanInletNode != thisFurnace.FurnaceInletNodeNum) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
-                        ShowContinueError(
-                            state, "When a blow through fan is specified, the fan inlet node name must be the same as the furnace inlet node name.");
-                        ShowContinueError(state, format("...Fan inlet node name     = {}", state.dataLoopNodes->NodeID(FanInletNode)));
-                        ShowContinueError(state,
-                                          format("...Furnace inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                if (furnace.FanInletNode != furnace.FurnaceInletNode) {
+                    if (furnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
+                        ShowSevereCustom(state, eoh, 
+                                         "When a blow through fan is specified, the fan inlet node name must be the same as the furnace inlet node name.");
+                        ShowContinueError(state, format("...Fan inlet node name     = {}", s_node->NodeID(furnace.FanInletNode)));
+                        ShowContinueError(state, format("...Furnace inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     } else {
-                        ShowContinueError(
-                            state,
-                            "When a blow through fan is specified, the fan inlet node name must be the same as the unitary system inlet node name.");
-                        ShowContinueError(state, format("...Fan inlet node name            = {}", state.dataLoopNodes->NodeID(FanInletNode)));
-                        ShowContinueError(
-                            state, format("...Unitary System inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                        ShowSevereCustom(state, eoh, 
+                                         "When a blow through fan is specified, the fan inlet node name must be the same as the unitary system inlet node name.");
+                        ShowContinueError(state, format("...Fan inlet node name            = {}", s_node->NodeID(furnace.FanInletNode)));
+                        ShowContinueError(state, format("...Unitary System inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     }
                     ErrorsFound = true;
                 }
                 // Fan outlet node name must be the same as the heating coil inlet node name
-                if (FanOutletNode != HeatingCoilInletNode) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(
-                        state,
-                        "When a blow through fan is specified, the fan outlet node name must be the same as the heating coil inlet node name.");
-                    ShowContinueError(state, format("...Fan outlet node name         = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                    ShowContinueError(state, format("...Heating coil inlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                if (furnace.FanOutletNode != furnace.HeatCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, 
+                                    "When a blow through fan is specified, the fan outlet node name must be the same as the heating coil inlet node name.");
+                    ShowContinueError(state, format("...Fan outlet node name         = {}", s_node->NodeID(furnace.FanOutletNode)));
+                    ShowContinueError(state, format("...Heating coil inlet node name = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
                 // Heating coil outlet node name must be the same as the furnace outlet node name
-                if (HeatingCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
-                        ShowContinueError(state,
-                                          "When a blow through fan is specified, the heating coil outlet node name must be the same as the furnace "
-                                          "outlet node name.");
-                        ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                        ShowContinueError(
-                            state, format("...Furnace outlet node name      = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                if (furnace.HeatCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                    if (furnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
+                        ShowSevereCustom(state, eoh, 
+                                         "When a blow through fan is specified, the heating coil outlet node name must be the same as the furnace "
+                                         "outlet node name.");
+                        ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                        ShowContinueError(state, format("...Furnace outlet node name      = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     } else {
-                        ShowContinueError(state,
-                                          "When a blow through fan is specified, the heating coil outlet node name must be the same as the unitary "
-                                          "system outlet node name.");
-                        ShowContinueError(state,
-                                          format("...Heating coil outlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                        ShowContinueError(
-                            state, format("...UnitarySystem outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                        ShowSevereCustom(state, eoh, 
+                                         "When a blow through fan is specified, the heating coil outlet node name must be the same as the unitary "
+                                         "system outlet node name.");
+                        ShowContinueError(state, format("...Heating coil outlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                        ShowContinueError(state, format("...UnitarySystem outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     }
                     ErrorsFound = true;
                 }
             } else { // draw through fan
                 CompSetHeatInlet = Alphas(3);
-                CompSetHeatOutlet = state.dataLoopNodes->NodeID(FanInletNode);
-                CompSetFanInlet = state.dataLoopNodes->NodeID(FanInletNode);
+                CompSetHeatOutlet = s_node->NodeID(furnace.FanInletNode);
+                CompSetFanInlet = s_node->NodeID(furnace.FanInletNode);
                 CompSetFanOutlet = Alphas(4);
                 // Heating coil inlet node name must not be the same as the furnace inlet node name
-                if (HeatingCoilInletNode != thisFurnace.FurnaceInletNodeNum) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
-                        ShowContinueError(state,
-                                          "When a draw through fan is specified, the heating coil inlet node name must be the same as the furnace "
-                                          "inlet node name.");
-                        ShowContinueError(state, format("...Heating coil inlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
-                        ShowContinueError(
-                            state, format("...Furnace inlet node name      = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                if (furnace.HeatCoilAirInletNode != furnace.FurnaceInletNode) {
+                    if (furnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
+                        ShowSevereCustom(state, eoh, 
+                                         "When a draw through fan is specified, the heating coil inlet node name must be the same as the furnace "
+                                         "inlet node name.");
+                        ShowContinueError(state, format("...Heating coil inlet node name = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
+                        ShowContinueError(state, format("...Furnace inlet node name      = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     } else {
-                        ShowContinueError(state,
-                                          "When a draw through fan is specified, the heating coil inlet node name must be the same as the unitary "
-                                          "system inlet node name.");
-                        ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
-                        ShowContinueError(
-                            state, format("...UnitarySystem inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                        ShowSevereCustom(state, eoh,
+                                         "When a draw through fan is specified, the heating coil inlet node name must be the same as the unitary "
+                                         "system inlet node name.");
+                        ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
+                        ShowContinueError(state, format("...UnitarySystem inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     }
                     ErrorsFound = true;
                 }
                 // Heating coil outlet node name must be the same as the fan inlet node name
-                if (HeatingCoilOutletNode != FanInletNode) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(
-                        state,
-                        "When a draw through fan is specified, the heating coil outlet node name must be the same as the fan inlet node name.");
-                    ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                    ShowContinueError(state, format("...Fan inlet node name           = {}", state.dataLoopNodes->NodeID(FanInletNode)));
+                if (furnace.HeatCoilAirOutletNode != furnace.FanInletNode) {
+                    ShowSevereCustom(state, eoh, "When a draw through fan is specified, the heating coil outlet node name must be the same as the fan inlet node name.");
+                    ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Fan inlet node name           = {}", s_node->NodeID(furnace.FanInletNode)));
                     ErrorsFound = true;
                 }
                 // Fan coil outlet node name must be the same as the furnace outlet node name
-                if (FanOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
-                        ShowContinueError(
-                            state,
-                            "When a draw through fan is specified, the fan outlet node name must be the same as the furnace outlet node name.");
-                        ShowContinueError(state, format("...Fan outlet node name     = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                        ShowContinueError(state,
-                                          format("...Furnace outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                if (furnace.FanOutletNode != furnace.FurnaceOutletNode) {
+                    if (furnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
+                        ShowSevereCustom(state, eoh, 
+                                         "When a draw through fan is specified, the fan outlet node name must be the same as the furnace outlet node name.");
+                        ShowContinueError(state, format("...Fan outlet node name     = {}", s_node->NodeID(furnace.FanOutletNode)));
+                        ShowContinueError(state, format("...Furnace outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     } else {
-                        ShowContinueError(state,
-                                          "When a draw through fan is specified, the fan outlet node name must be the same as the unitary system "
-                                          "outlet node name.");
-                        ShowContinueError(state, format("...Fan outlet node name           = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                        ShowContinueError(
-                            state, format("...UnitarySystem outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                        ShowSevereCustom(state, eoh, 
+                                         "When a draw through fan is specified, the fan outlet node name must be the same as the unitary system "
+                                         "outlet node name.");
+                        ShowContinueError(state, format("...Fan outlet node name           = {}", s_node->NodeID(furnace.FanOutletNode)));
+                        ShowContinueError(state, format("...UnitarySystem outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     }
                     ErrorsFound = true;
                 }
@@ -1269,50 +1117,50 @@ namespace Furnaces {
 
             // Add fan to component sets array
             BranchNodeConnections::SetUpCompSets(
-                state, CurrentModuleObject, thisFurnace.Name, Alphas(7), Alphas(8), CompSetFanInlet, CompSetFanOutlet);
+                state, CurrentModuleObject, furnace.Name, Alphas(7), Alphas(8), CompSetFanInlet, CompSetFanOutlet);
             // Add heating coil to component sets array
             BranchNodeConnections::SetUpCompSets(
-                state, CurrentModuleObject, thisFurnace.Name, Alphas(10), Alphas(11), CompSetHeatInlet, CompSetHeatOutlet);
+                state, CurrentModuleObject, furnace.Name, Alphas(10), Alphas(11), CompSetHeatInlet, CompSetHeatOutlet);
 
             // Set the furnace max outlet temperature
-            thisFurnace.DesignMaxOutletTemp = Numbers(1);
+            furnace.DesignMaxOutletTemp = Numbers(1);
 
             // Set the furnace design fan volumetric flow rate
-            thisFurnace.DesignFanVolFlowRate = Numbers(2);
+            furnace.DesignFanVolFlowRate = Numbers(2);
 
             // Compare the flow rates.
-            if (thisFurnace.ActualFanVolFlowRate != DataSizing::AutoSize && thisFurnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.DesignFanVolFlowRate > thisFurnace.ActualFanVolFlowRate) {
+            if (furnace.ActualFanVolFlowRate != DataSizing::AutoSize && furnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.DesignFanVolFlowRate > furnace.ActualFanVolFlowRate) {
                     ShowWarningError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(
                         state, format("... The {} > Max Volume Flow Rate defined in the associated fan object, should be <=.", cNumericFields(2)));
                     ShowContinueError(state,
                                       format("... Entered value = {:.4R}... Fan [{} = {}] Max Value = {:.4R}",
-                                             thisFurnace.DesignFanVolFlowRate,
-                                             HVAC::fanTypeNames[(int)thisFurnace.fanType],
+                                             furnace.DesignFanVolFlowRate,
+                                             HVAC::fanTypeNames[(int)furnace.fanType],
                                              FanName,
-                                             thisFurnace.ActualFanVolFlowRate));
+                                             furnace.ActualFanVolFlowRate));
                     ShowContinueError(state, " The HVAC system  flow rate is reset to the fan flow rate and the simulation continues.");
-                    thisFurnace.DesignFanVolFlowRate = thisFurnace.ActualFanVolFlowRate;
+                    furnace.DesignFanVolFlowRate = furnace.ActualFanVolFlowRate;
                 }
             }
-            if (thisFurnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.DesignFanVolFlowRate <= 0.0) {
+            if (furnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.DesignFanVolFlowRate <= 0.0) {
                     ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(state, format("... The {} <= 0.0, it must be > 0.0.", cNumericFields(2)));
-                    ShowContinueError(state, format("... Entered value = {:.2R}", thisFurnace.DesignFanVolFlowRate));
+                    ShowContinueError(state, format("... Entered value = {:.2R}", furnace.DesignFanVolFlowRate));
                     ErrorsFound = true;
                 }
             }
 
             //       HeatOnly furnace has only 1 flow rate, initialize other variables used in this module
-            thisFurnace.MaxHeatAirVolFlow = thisFurnace.DesignFanVolFlowRate;
-            thisFurnace.MaxCoolAirVolFlow = thisFurnace.DesignFanVolFlowRate;
-            thisFurnace.MaxNoCoolHeatAirVolFlow = thisFurnace.DesignFanVolFlowRate;
-            thisFurnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
+            furnace.MaxHeatAirVolFlow = furnace.DesignFanVolFlowRate;
+            furnace.MaxCoolAirVolFlow = furnace.DesignFanVolFlowRate;
+            furnace.MaxNoCoolHeatAirVolFlow = furnace.DesignFanVolFlowRate;
+            furnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
 
             // Set heating convergence tolerance
-            thisFurnace.HeatingConvergenceTolerance = 0.001;
+            furnace.HeatingConvergenceTolerance = 0.001;
 
             // set minimum outdoor temperature for compressor operation
             SetMinOATCompressor(state, FurnaceNum, cCurrentModuleObject, ErrorsFound);
@@ -1322,37 +1170,24 @@ namespace Furnaces {
         // Get the data for the HeatCool Furnace or UnitarySystem
         for (int HeatCoolNum = 1; HeatCoolNum <= NumHeatCool + NumUnitaryHeatCool; ++HeatCoolNum) {
 
-            FanInletNode = 0;
-            FanOutletNode = 0;
-            CoolingCoilInletNode = 0;
-            CoolingCoilOutletNode = 0;
-            HeatingCoilInletNode = 0;
-            HeatingCoilOutletNode = 0;
-            int ReheatCoilInletNode = 0;
-            int ReheatCoilOutletNode = 0;
-            CoolingCoilType = ' ';
-            CoolingCoilName = ' ';
-            HeatingCoilType = ' ';
-            HeatingCoilName = ' ';
-
             FurnaceNum = HeatCoolNum + NumHeatOnly + NumUnitaryHeatOnly;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
             //      Furnace and UnitarySystem objects are both read in here.
             //      Will still have 2 differently named objects for the user, but read in with 1 DO loop.
             if (HeatCoolNum <= NumHeatCool) {
                 CurrentModuleObject = "AirLoopHVAC:Unitary:Furnace:HeatCool";
                 currentModuleObjectType = DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryFurnaceHeatCool;
-                thisFurnace.type = HVAC::UnitarySysType::Furnace_HeatCool;
+                furnace.type = HVAC::UnitarySysType::Furnace_HeatCool;
                 GetObjectNum = HeatCoolNum;
             } else {
                 CurrentModuleObject = "AirLoopHVAC:UnitaryHeatCool";
                 currentModuleObjectType = DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatCool;
-                thisFurnace.type = HVAC::UnitarySysType::Unitary_HeatCool;
+                furnace.type = HVAC::UnitarySysType::Unitary_HeatCool;
                 GetObjectNum = HeatCoolNum - NumHeatCool;
             }
 
-            thisFurnace.iterationMode.allocate(3);
+            furnace.iterationMode.allocate(3);
 
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      CurrentModuleObject,
@@ -1370,18 +1205,18 @@ namespace Furnaces {
             GlobalNames::VerifyUniqueInterObjectName(
                 state, state.dataFurnaces->UniqueFurnaceNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
 
-            thisFurnace.Name = Alphas(1);
+            furnace.Name = Alphas(1);
 
-            ErrorObjectHeader eoh{routineName, CurrentModuleObject, thisFurnace.Name};
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, furnace.Name};
 
             if (lAlphaBlanks(2)) {
-                thisFurnace.availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((thisFurnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                furnace.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((furnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
                 ErrorsFound = true;
             }
 
-            thisFurnace.FurnaceInletNodeNum = NodeInputManager::GetOnlySingleNode(state,
+            furnace.FurnaceInletNode = NodeInputManager::GetOnlySingleNode(state,
                                                                                   Alphas(3),
                                                                                   ErrorsFound,
                                                                                   currentModuleObjectType,
@@ -1390,7 +1225,7 @@ namespace Furnaces {
                                                                                   DataLoopNode::ConnectionType::Inlet,
                                                                                   NodeInputManager::CompFluidStream::Primary,
                                                                                   DataLoopNode::ObjectIsParent);
-            thisFurnace.FurnaceOutletNodeNum = NodeInputManager::GetOnlySingleNode(state,
+            furnace.FurnaceOutletNode = NodeInputManager::GetOnlySingleNode(state,
                                                                                    Alphas(4),
                                                                                    ErrorsFound,
                                                                                    currentModuleObjectType,
@@ -1403,27 +1238,27 @@ namespace Furnaces {
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
             if (lAlphaBlanks(5)) {
-                thisFurnace.fanOp = HVAC::FanOp::Cycling;
-            } else if ((thisFurnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(5))) == nullptr) {
+                furnace.fanOp = HVAC::FanOp::Cycling;
+            } else if ((furnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(5))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(5), Alphas(5));
                 ErrorsFound = true;
             }
 
             // Get the Controlling Zone or Location of the Furnace Thermostat
-            thisFurnace.ControlZoneNum = Util::FindItemInList(Alphas(6), state.dataHeatBal->Zone);
-            if (thisFurnace.ControlZoneNum == 0) {
+            furnace.ControlZoneNum = Util::FindItemInList(Alphas(6), state.dataHeatBal->Zone);
+            if (furnace.ControlZoneNum == 0) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(6), Alphas(6)));
                 ErrorsFound = true;
             }
 
             // Get the node number for the zone with the thermostat
-            if (thisFurnace.ControlZoneNum > 0) {
+            if (furnace.ControlZoneNum > 0) {
                 AirNodeFound = false;
                 AirLoopFound = false;
-                int ControlledZoneNum = thisFurnace.ControlZoneNum;
+                int ControlledZoneNum = furnace.ControlZoneNum;
                 //             Find the controlled zone number for the specified thermostat location
-                thisFurnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
+                furnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
                 //             Determine if system is on air loop served by the thermostat location specified
                 for (int zoneInNode = 1; zoneInNode <= state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).NumInletNodes; ++zoneInNode) {
                     int AirLoopNumber = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNodeAirLoopNum(zoneInNode);
@@ -1439,17 +1274,17 @@ namespace Furnaces {
                                         CurrentModuleObject))
                                     continue;
                                 AirLoopFound = true;
-                                thisFurnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
+                                furnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
                                 break;
                             }
                             if (AirLoopFound) break;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumTempControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumComfortControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                     }
@@ -1474,28 +1309,28 @@ namespace Furnaces {
             // Get fan data
             FanName = Alphas(8);
 
-            thisFurnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(7)));
+            furnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(7)));
 
-            if (thisFurnace.fanType != HVAC::FanType::OnOff && thisFurnace.fanType != HVAC::FanType::Constant) {
+            if (furnace.fanType != HVAC::FanType::OnOff && furnace.fanType != HVAC::FanType::Constant) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(7), Alphas(7)));
                 ErrorsFound = true;
 
-            } else if ((thisFurnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
+            } else if ((furnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(8), FanName);
                 ErrorsFound = true;
 
             } else {
-                auto *fan = state.dataFans->fans(thisFurnace.FanIndex);
-                thisFurnace.ActualFanVolFlowRate = fan->maxAirFlowRate;
-                FanInletNode = fan->inletNodeNum;
-                FanOutletNode = fan->outletNodeNum;
-                thisFurnace.fanAvailSched = fan->availSched;
+                auto *fan = state.dataFans->fans(furnace.FanIndex);
+                furnace.ActualFanVolFlowRate = fan->maxAirFlowRate;
+                furnace.FanInletNode = fan->inletNodeNum;
+                furnace.FanOutletNode = fan->outletNodeNum;
+                furnace.fanAvailSched = fan->availSched;
 
                 // Check fan's schedule for cycling fan operation if constant volume fan is used
-                if (thisFurnace.fanOpModeSched != nullptr && thisFurnace.fanType == HVAC::FanType::Constant) {
-                    if (!thisFurnace.fanOpModeSched->checkMinMaxVals(state, Clusive::Ex, 0.0, Clusive::In, 1.0)) {
-                        Sched::ShowSevereBadMinMax(
+                if (furnace.fanOpModeSched != nullptr && furnace.fanType == HVAC::FanType::Constant) {
+                    if (!furnace.fanOpModeSched->checkMinMaxVals(state, Clusive::Ex, 0.0, Clusive::In, 1.0)) {
+                        Sched::ShowSevereBadMinMax( // MAKE THIS STOP!!!!!
                             state,
                             eoh,
                             cAlphaFields(5),
@@ -1507,417 +1342,189 @@ namespace Furnaces {
                             format("For {} = {}, fan operating mode must be continuous (schedule values > 0)", cAlphaFields(7), Alphas(7)));
                         ErrorsFound = true;
                     }
-                } else if (lAlphaBlanks(5) && thisFurnace.fanType != HVAC::FanType::OnOff) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, thisFurnace.Name));
+                } else if (lAlphaBlanks(5) && furnace.fanType != HVAC::FanType::OnOff) {
+                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, furnace.Name));
                     ShowContinueError(state, format("{} = {}", cAlphaFields(7), Alphas(7)));
                     ShowContinueError(state, format("Fan type must be Fan:OnOff when {} = Blank.", cAlphaFields(5)));
                     ErrorsFound = true;
                 }
             }
 
-            thisFurnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(9)));
-            assert(thisFurnace.fanPlace != HVAC::FanPlace::Invalid);
+            furnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(9)));
+            assert(furnace.fanPlace != HVAC::FanPlace::Invalid);
 
             // Get coil data
-            HeatingCoilType = Alphas(10);
-            HeatingCoilName = Alphas(11);
-            HeatingCoilPLFCurveIndex = 0;
-            thisFurnace.HeatingCoilType = HeatingCoilType;
-            thisFurnace.HeatingCoilName = HeatingCoilName;
-            if (Util::SameString(HeatingCoilType, "Coil:Heating:Fuel") || Util::SameString(HeatingCoilType, "Coil:Heating:Electric")) {
-                errFlag = false;
-                thisFurnace.HeatingCoilType_Num = HeatingCoils::GetHeatingCoilTypeNum(state, HeatingCoilType, HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            furnace.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(10)));
+            furnace.HeatCoilName = Alphas(11);
+            furnace.HeatCoilPLFCurveIndex = 0;
+            
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                furnace.heatCoilType == HVAC::CoilType::HeatingElectric) {
+              
+                furnace.HeatCoilNum = HeatingCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) { 
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), Alphas(11));
                     ErrorsFound = true;
                 } else {
-
-                    ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-
-                    } else { // mine data from heating coil
-
-                        // Get heating coil index
-                        errFlag = false;
-                        HeatingCoils::GetCoilIndex(state, HeatingCoilName, thisFurnace.HeatingCoilIndex, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the design heating capacity
-                        errFlag = false;
-                        thisFurnace.DesignHeatingCapacity = HeatingCoils::GetCoilCapacity(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Heating Coil Inlet Node
-                        errFlag = false;
-                        HeatingCoilInletNode = HeatingCoils::GetCoilInletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Heating Coil Outlet Node
-                        errFlag = false;
-                        HeatingCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Heating Coil PLF Curve Index
-                        errFlag = false;
-                        HeatingCoilPLFCurveIndex = HeatingCoils::GetHeatingCoilPLFCurveIndex(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                    } // IF (IsNotOK) THEN
+                    furnace.DesignHeatingCapacity = HeatingCoils::GetCoilCapacity(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilPLFCurveIndex = HeatingCoils::GetCoilPLFCurveIndex(state, furnace.HeatCoilNum);
                 }
 
-            } else if (Util::SameString(HeatingCoilType, "Coil:Heating:Water")) {
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingWater;
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWater) {
+                furnace.HeatCoilNum = WaterCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), Alphas(11));
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    // Get the Heating Coil water Inlet or control Node number
-                    errFlag = false;
-                    thisFurnace.CoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil hot water max volume flow rate
-                    errFlag = false;
-                    thisFurnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil Inlet Node
-                    errFlag = false;
-                    HeatingCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirInletNode = HeatingCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil Outlet Node
-                    errFlag = false;
-                    HeatingCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirOutletNode = HeatingCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
+                } else {
+                    furnace.HeatCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, furnace.HeatCoilNum);
+                    furnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
                     // check if user has also used a water coil controller, which they should not do
                     errFlag = false;
-                    HVACControllers::CheckCoilWaterInletNode(state, thisFurnace.CoilControlNode, errFlag);
+                    HVACControllers::CheckCoilWaterInletNode(state, furnace.HeatCoilControlNode, errFlag);
                     if (!errFlag) { // then did find a controller so that is bad
                         ShowSevereError(state,
-                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, thisFurnace.Name));
+                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, furnace.Name));
                         ShowContinueError(state, "Hot water coils are controlled directly by unitary and furnace systems.");
                         ShowContinueError(state, "No water coil controller should be input for the coil.");
                         ErrorsFound = true;
                     }
                 }
-
-            } else if (Util::SameString(HeatingCoilType, "Coil:Heating:Steam")) {
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingSteam;
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                furnace.HeatCoilNum = SteamCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.HeatCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    errFlag = false;
-                    thisFurnace.HeatingCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", HeatingCoilName, errFlag);
-                    if (thisFurnace.HeatingCoilIndex == 0) {
-                        ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(11), HeatingCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil steam inlet node number
-                    errFlag = false;
-                    thisFurnace.CoilControlNode = SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil steam max volume flow rate
-                    thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, errFlag);
-                    if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) {
-                        SteamDensity =
-                            Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, getAirLoopHVACHeatCoolInput);
-                        thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity;
-                    }
-
-                    // Get the Heating Coil Inlet Node
-                    errFlag = false;
-                    HeatingCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisFurnace.HeatingCoilIndex, HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirInletNode = HeatingCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
+                } else {
+                    furnace.HeatCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, furnace.HeatCoilNum);
+                    furnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.HeatCoilNum);
+                    if (furnace.MaxHeatCoilFluidFlow > 0.0) {
+                        furnace.MaxHeatCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, getAirLoopHVACHeatCoolInput);
                     }
 
-                    // Get the Heating Coil Outlet Node
-                    errFlag = false;
-                    HeatingCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisFurnace.HeatingCoilIndex, HeatingCoilName, errFlag);
-                    thisFurnace.HWCoilAirOutletNode = HeatingCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
+                    furnace.HeatCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
                 }
 
             } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(11), Alphas(11)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(11), Alphas(11));
                 ErrorsFound = true;
             } // IF (Furnace(FurnaceNum)%HeatingCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
 
             // Get Cooling Coil Information if available
-            CoolingCoilType = Alphas(12);
-            CoolingCoilName = Alphas(13);
+            furnace.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(12)));
+            furnace.CoolCoilName = Alphas(13);
             //       Find the type of coil. Do not print message since this may not be the correct coil type.
-            errFlag = false;
-            PrintMessage = false;
-
-            if (Util::SameString(CoolingCoilType, "COIL:COOLING:DX:VARIABLESPEED") ||
-                Util::SameString(CoolingCoilType, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) {
-                thisFurnace.CoolingCoilType_Num = HVAC::Coil_CoolingAirToAirVariableSpeed;
-                if (Util::SameString(CoolingCoilType, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) thisFurnace.bIsIHP = true;
-            } else {
-                thisFurnace.CoolingCoilType_Num = DXCoils::GetCoilTypeNum(state, CoolingCoilType, CoolingCoilName, errFlag, PrintMessage);
+            if (Util::SameString(Alphas(12), "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) {
+                furnace.coolCoilType = HVAC::CoilType::CoolingDXVariableSpeed;
+                furnace.isIHP = true;
             }
+            
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
 
-            // If coil type not found, check to see if a HX assisted cooling coil is used.
-            if (thisFurnace.CoolingCoilType_Num == 0) {
-                errFlag = false;
-                thisFurnace.CoolingCoilType_Num =
-                    HVACHXAssistedCoolingCoil::GetCoilGroupTypeNum(state, CoolingCoilType, CoolingCoilName, errFlag, PrintMessage);
-            }
-
-            if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-                ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                furnace.CoolCoilNum = DXCoils::GetCoilIndex(state, furnace.CoolCoilName);
+                if (furnace.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.CoolCoilName);
                     ErrorsFound = true;
+                } else {
+                    furnace.DesignCoolingCapacity = DXCoils::GetCoilCapacity(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirInletNode = DXCoils::GetCoilAirInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = DXCoils::GetCoilAirOutletNode(state, furnace.CoolCoilNum);
+                }
 
-                } else { // mine data from DX cooling coil
-
-                    // Get DX cooling coil index
-                    DXCoils::GetDXCoilIndex(state, CoolingCoilName, thisFurnace.CoolingCoilIndex, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get DX cooling coil capacity
-                    errFlag = false;
-                    thisFurnace.DesignCoolingCapacity = DXCoils::GetCoilCapacity(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Cooling Coil Nodes
-                    errFlag = false;
-                    CoolingCoilInletNode = DXCoils::GetCoilInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode = DXCoils::GetCoilOutletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                if (furnace.isIHP) {
+                    furnace.ihpName = furnace.CoolCoilName;
+                    furnace.ihpNum = IntegratedHeatPump::GetIHPIndex(state, furnace.ihpName);
+                    if (furnace.ihpNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.ihpName);
                         ErrorsFound = true;
-                    }
-
-                    // Get outdoor condenser node from DX coil object
-                    errFlag = false;
-                    if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                        if (thisFurnace.bIsIHP) {
-                            IHPCoilIndex = IntegratedHeatPump::GetCoilIndexIHP(state, CoolingCoilType, CoolingCoilName, errFlag);
-                            IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(IHPCoilIndex).SCCoilName;
-                            thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, IHPCoilName, errFlag);
+                    } else {
+                        furnace.CoolCoilName = state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).SCCoilName;
+                        furnace.CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, furnace.CoolCoilName);
+                        // This probably doesn't need to be done because the IHP itself did this check.
+                        if (furnace.CoolCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, format("{}.SCCoilName", cAlphaFields(13)), furnace.CoolCoilName);
+                            ErrorsFound = true;
                         } else {
-                            thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, CoolingCoilName, errFlag);
+                            furnace.CondenserNodeNum = VariableSpeedCoils::GetCoilCondenserInletNode(state, furnace.CoolCoilNum);
                         }
-                    } else {
-                        thisFurnace.CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
                     }
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                } else { // !furnace.isIHP
+                    furnace.CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, furnace.CoolCoilName);
+                    if (furnace.CoolCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.CoolCoilName);
                         ErrorsFound = true;
                     }
+                }                  
 
-                } // IF (IsNotOK) THEN
-
-                // Push heating coil PLF curve index to DX coil
-                if (HeatingCoilPLFCurveIndex > 0) {
-                    DXCoils::SetDXCoolingCoilData(state, thisFurnace.CoolingCoilIndex, ErrorsFound, HeatingCoilPLFCurveIndex);
+                // At this point, CoolCoilNum should be set correctly regardless of whether this is an IHP or not
+                if (furnace.CoolCoilNum != 0) {
+                    furnace.CoolCoilAirInletNode = VariableSpeedCoils::GetCoilAirInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = VariableSpeedCoils::GetCoilAirOutletNode(state, furnace.CoolCoilNum);
+                    furnace.CondenserNodeNum = VariableSpeedCoils::GetCoilCondenserInletNode(state, furnace.CoolCoilNum);
+                    furnace.DesignCoolingCapacity = VariableSpeedCoils::GetCoilCapacity(state, furnace.CoolCoilNum);
+                    furnace.MaxCoolAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRate(state, furnace.CoolCoilNum);
                 }
-
-            } else if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                
+                // Push heating coil PLF curve index to DX coil
+                if (furnace.HeatCoilPLFCurveIndex > 0) {
+                    DXCoils::SetCoilHeatingPLFCurve(state, furnace.CoolCoilNum, furnace.HeatCoilPLFCurveIndex);
+                }
+
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                // At this point, the variables that reference the
+                // HXAssisted coil become the hxCoolCoil vars so that
+                // the (plain) CoolCoil vars can reference the child DX Coil
+                // that is embedded in the HXAssisted coil
+                furnace.CoolCoilNum = HXAssistCoil::GetCoilIndex(state, furnace.CoolCoilName);
+                if (furnace.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.CoolCoilName);
                     ErrorsFound = true;
-
-                } else { // mine data from heat exchanger assisted cooling coil
-
-                    // Get DX heat exchanger assisted cooling coil index
-                    HVACHXAssistedCoolingCoil::GetHXDXCoilIndex(state, CoolingCoilName, thisFurnace.CoolingCoilIndex, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get DX cooling coil capacity
-                    errFlag = false;
-                    thisFurnace.DesignCoolingCapacity = HVACHXAssistedCoolingCoil::GetCoilCapacity(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Cooling Coil Nodes
-                    errFlag = false;
-                    CoolingCoilInletNode = HVACHXAssistedCoolingCoil::GetCoilInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode = HVACHXAssistedCoolingCoil::GetCoilOutletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get outdoor condenser node from heat exchanger assisted DX coil object
-                    errFlag = false;
-                    std::string ChildCoolingCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, CoolingCoilType, CoolingCoilName, IsNotOK);
-                    std::string ChildCoolingCoilType = HVACHXAssistedCoolingCoil::GetHXDXCoilType(state, CoolingCoilType, CoolingCoilName, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // if (thisFurnace.CoolingCoilType_Num == CoilDX_CoolingHXAssisted) {
-                    if (Util::SameString(ChildCoolingCoilType, "COIL:COOLING:DX")) {
-
-                        int childCCIndex = CoilCoolingDX::factory(state, ChildCoolingCoilName);
-                        if (childCCIndex < 0) {
-                            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, Alphas(1)));
-                            errFlag = true;
-                            ErrorsFound = true;
-                        }
-                        auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex];
-
-                        thisFurnace.CondenserNodeNum = newCoil.condInletNodeIndex;
-
-                    }
-                    // else if (thisFurnace.CoolingCoilType_Num == Coil_CoolingAirToAirVariableSpeed) {
-                    else if (Util::SameString(ChildCoolingCoilType, "Coil:Cooling:DX:VariableSpeed")) {
-                        if (thisFurnace.bIsIHP) {
-                            IHPCoilIndex = IntegratedHeatPump::GetCoilIndexIHP(state, CoolingCoilType, CoolingCoilName, errFlag);
-                            IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(IHPCoilIndex).SCCoilName;
-                            thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, IHPCoilName, errFlag);
-                        } else {
-                            thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, CoolingCoilName, errFlag);
-                        }
+                } else {
+                    furnace.DesignCoolingCapacity = HXAssistCoil::GetCoilCapacity(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirInletNode = HXAssistCoil::GetCoilAirInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = HXAssistCoil::GetCoilAirOutletNode(state, furnace.CoolCoilNum);
+                     
+                    furnace.childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, furnace.CoolCoilNum);
+                    furnace.childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, furnace.CoolCoilNum);
+                    furnace.childCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(state, furnace.CoolCoilNum);
+                    
+                    // if (furnace.CoolingCoilType_Num == CoilDX_CoolingHXAssisted) {
+                    if (furnace.childCoolCoilType == HVAC::CoilType::CoolingDX) {
+                        auto const &coilDX = state.dataCoilCoolingDX->coilCoolingDXs[furnace.childCoolCoilNum];
+                        furnace.CondenserNodeNum = coilDX.condInletNodeIndex;
+                    } else if (furnace.childCoolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                        furnace.CondenserNodeNum = VariableSpeedCoils::GetCoilCondenserInletNode(state, furnace.childCoolCoilNum);
                     } else {
-                        thisFurnace.CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(
-                            state,
-                            "COIL:COOLING:DX:SINGLESPEED",
-                            HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, CoolingCoilType, CoolingCoilName, errFlag),
-                            errFlag);
-                    }
-
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
+                        furnace.CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(state, furnace.CoolCoilNum);
                     }
 
                     // Push heating coil PLF curve index to DX coil
-                    if (HeatingCoilPLFCurveIndex > 0) {
+                    if (furnace.HeatCoilPLFCurveIndex > 0) {
                         // get the actual index to the DX cooling coil object
-                        DXCoilIndex = HVACHXAssistedCoolingCoil::GetActualDXCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
-                        thisFurnace.ActualDXCoilIndexForHXAssisted = DXCoilIndex;
-                        int ActualCoolCoilType =
-                            HVACHXAssistedCoolingCoil::GetCoilObjectTypeNum(state, CoolingCoilType, CoolingCoilName, errFlag, true);
-                        if (ActualCoolCoilType == HVAC::CoilDX_CoolingSingleSpeed) {
-                            DXCoils::SetDXCoolingCoilData(state, DXCoilIndex, ErrorsFound, HeatingCoilPLFCurveIndex);
+                        if (furnace.childCoolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+                            DXCoils::SetCoilHeatingPLFCurve(state, furnace.childCoolCoilNum, furnace.HeatCoilPLFCurveIndex);
                         }
                         // what could we do for VS coil here? odd thing here
                     }
+                 }
 
-                } // IF (IsNotOK) THEN
-            } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                // BOS ADDED, AUG/2012, VARIIABLE SPEED DX COOLING COIL
-                //  Furnace(FurnaceNum)%DXCoolCoilType = 'COIL:COOLING:DX:VARIABLESPEED'
-                //  Furnace(FurnaceNum)%DXCoolCoilName = CoolingCoilName
-                if (Util::SameString(CoolingCoilType, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) thisFurnace.bIsIHP = true;
-                ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                } else {
-                    errFlag = false;
-                    if (thisFurnace.bIsIHP) {
-                        thisFurnace.CoolingCoilIndex = IntegratedHeatPump::GetCoilIndexIHP(state, CoolingCoilType, CoolingCoilName, errFlag);
-                        IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilName;
-                    } else {
-                        thisFurnace.CoolingCoilIndex =
-                            VariableSpeedCoils::GetCoilIndexVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                        IHPCoilName = CoolingCoilName;
-                    }
-
-                    if (errFlag) {
-                        ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    if (thisFurnace.bIsIHP) {
-                        CoolingCoilInletNode =
-                            VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                        CoolingCoilOutletNode =
-                            VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                        thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, IHPCoilName, errFlag);
-                    } else {
-                        CoolingCoilInletNode = VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                        CoolingCoilOutletNode = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                        thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, CoolingCoilName, errFlag);
-                    }
-
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-                }
-            } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(12), Alphas(12)));
-                ErrorsFound = true;
-            }
+            } else {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(12), Alphas(12));
+                ErrorsFound = true;
+            }
 
             if (Util::SameString(Alphas(14), "None") || Util::SameString(Alphas(14), "Multimode") || Util::SameString(Alphas(14), "CoolReheat")) {
                 AirNodeFound = false;
                 if (Util::SameString(Alphas(14), "Multimode")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::Multimode;
-                    thisFurnace.Humidistat = true;
-                    if (thisFurnace.CoolingCoilType_Num != HVAC::CoilDX_CoolingHXAssisted) {
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::Multimode;
+                    furnace.Humidistat = true;
+                    if (furnace.coolCoilType != HVAC::CoilType::CoolingDXHXAssisted) {
                         ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                         ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(14), Alphas(14)));
                         ShowContinueError(state, "Multimode control must be used with a Heat Exchanger Assisted Cooling Coil.");
@@ -1925,33 +1532,32 @@ namespace Furnaces {
                             ShowContinueError(state,
                                               "Dehumidification control type is assumed to be None since a reheat coil has not been specified and "
                                               "the simulation continues.");
-                            thisFurnace.Humidistat = false;
-                            thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                            furnace.Humidistat = false;
+                            furnace.DehumidControlType_Num = DehumidificationControlMode::None;
                         } else {
                             ShowContinueError(state, "Dehumidification control type is assumed to be CoolReheat and the simulation continues.");
-                            thisFurnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
+                            furnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
                         }
                     }
-                }
-                if (Util::SameString(Alphas(14), "CoolReheat")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
-                    thisFurnace.Humidistat = true;
+                } else if (Util::SameString(Alphas(14), "CoolReheat")) {
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
+                    furnace.Humidistat = true;
                     if (lAlphaBlanks(15)) {
                         ShowWarningError(state, format("{} \"{}\"", CurrentModuleObject, Alphas(1)));
                         ShowContinueError(state,
                                           "Dehumidification control type is assumed to be None since a reheat coil has not been specified and the "
                                           "simulation continues.");
-                        thisFurnace.Humidistat = false;
-                        thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                        furnace.Humidistat = false;
+                        furnace.DehumidControlType_Num = DehumidificationControlMode::None;
                     }
+                } else if (Util::SameString(Alphas(14), "None")) {
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                    furnace.Humidistat = false;
                 }
-                if (Util::SameString(Alphas(14), "None")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
-                    thisFurnace.Humidistat = false;
-                }
-                if (thisFurnace.Humidistat) {
+                
+                if (furnace.Humidistat) {
                     for (HStatZoneNum = 1; HStatZoneNum <= state.dataZoneCtrls->NumHumidityControlZones; ++HStatZoneNum) {
-                        if (state.dataZoneCtrls->HumidityControlZone(HStatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                        if (state.dataZoneCtrls->HumidityControlZone(HStatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                         AirNodeFound = true;
                     }
                     if (!AirNodeFound) {
@@ -1962,328 +1568,191 @@ namespace Furnaces {
                     }
                 }
             } else { // invalid input
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(14), Alphas(14)));
-                thisFurnace.Humidistat = false;
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(14), Alphas(14));
+                furnace.Humidistat = false;
                 ErrorsFound = true;
             }
 
             //       Check placement of cooling coil with respect to fan placement and dehumidification control type
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                if (FanOutletNode == HeatingCoilInletNode && thisFurnace.DehumidControlType_Num != DehumidificationControlMode::CoolReheat) {
-                    thisFurnace.CoolingCoilUpstream = false;
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                if (furnace.FanOutletNode == furnace.HeatCoilAirInletNode &&
+                    furnace.DehumidControlType_Num != DehumidificationControlMode::CoolReheat) {
+                    furnace.CoolCoilUpstream = false;
                 }
             } else {
-                if (HeatingCoilOutletNode == CoolingCoilInletNode && thisFurnace.DehumidControlType_Num != DehumidificationControlMode::CoolReheat) {
-                    thisFurnace.CoolingCoilUpstream = false;
+                if (furnace.HeatCoilAirOutletNode == furnace.CoolCoilAirInletNode &&
+                    furnace.DehumidControlType_Num != DehumidificationControlMode::CoolReheat) {
+                    furnace.CoolCoilUpstream = false;
                 }
             }
 
             // Get reheat coil data if humidistat is used
-            ReheatingCoilType = Alphas(15);
-            ReheatingCoilName = Alphas(16);
-            thisFurnace.SuppHeatCoilType = ReheatingCoilType;
-            thisFurnace.SuppHeatCoilName = ReheatingCoilName;
-            errFlag = false;
-            if (!lAlphaBlanks(15)) {
-                if (Util::SameString(ReheatingCoilType, "Coil:Heating:Fuel") || Util::SameString(ReheatingCoilType, "Coil:Heating:Electric") ||
-                    Util::SameString(ReheatingCoilType, "Coil:Heating:Desuperheater")) {
+            furnace.suppHeatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(15)));
+            furnace.SuppCoilName = Alphas(16);
 
-                    thisFurnace.SuppHeatCoilType_Num = HeatingCoils::GetHeatingCoilTypeNum(state, ReheatingCoilType, ReheatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            if (!lAlphaBlanks(15)) {
+                if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                    furnace.suppHeatCoilType == HVAC::CoilType::HeatingElectric ||
+                    furnace.suppHeatCoilType == HVAC::CoilType::HeatingDesuperheater) {
+
+                    // Get the heating coil index
+                    furnace.SuppCoilNum = HeatingCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                    if (furnace.SuppCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(15), furnace.SuppCoilName);
                         ErrorsFound = true;
                     } else {
-
-                        ValidateComponent(state, ReheatingCoilType, ReheatingCoilName, IsNotOK, CurrentModuleObject);
-                        if (IsNotOK) {
-                            ShowContinueError(state, format("In {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-
-                        } else { // mine data from reheat coil
-
-                            // Get the heating coil index
-                            HeatingCoils::GetCoilIndex(state, ReheatingCoilName, thisFurnace.SuppHeatCoilIndex, IsNotOK);
-                            if (IsNotOK) {
-                                ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                                ErrorsFound = true;
-                            }
-
-                            // Get the design supplemental heating capacity
-                            errFlag = false;
-                            thisFurnace.DesignSuppHeatingCapacity =
-                                HeatingCoils::GetCoilCapacity(state, ReheatingCoilType, ReheatingCoilName, errFlag);
-                            if (errFlag) {
-                                ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                                ErrorsFound = true;
-                            }
-
-                            // Get the Reheat Coil Inlet Node
-                            errFlag = false;
-                            ReheatCoilInletNode = HeatingCoils::GetCoilInletNode(state, ReheatingCoilType, ReheatingCoilName, errFlag);
-                            if (errFlag) {
-                                ShowContinueError(state, format("...occurs in {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                                ErrorsFound = true;
-                            }
-
-                            // Get the Reheat Coil Outlet Node
-                            errFlag = false;
-                            ReheatCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, ReheatingCoilType, ReheatingCoilName, errFlag);
-                            if (errFlag) {
-                                ShowContinueError(state, format("...occurs in {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                                ErrorsFound = true;
-                            }
-
-                        } // IF (IsNotOK) THEN
+                        furnace.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, furnace.SuppCoilNum);
+                        furnace.SuppCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                        furnace.SuppCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
                     }
 
-                } else if (Util::SameString(ReheatingCoilType, "Coil:Heating:Water")) {
-                    thisFurnace.SuppHeatCoilType_Num = HVAC::Coil_HeatingWater;
-                    ValidateComponent(state, ReheatingCoilType, ReheatingCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                } else if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
+                    // Get the Heating Coil water Inlet or control Node number
+                    furnace.SuppCoilNum = WaterCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                    if (furnace.SuppCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(16), furnace.SuppCoilName);
                         ErrorsFound = true;
-                    } else { // mine data from heating coil object
-
-                        // Get the Heating Coil water Inlet or control Node number
-                        errFlag = false;
-                        thisFurnace.SuppCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", ReheatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the ReHeat Coil hot water max volume flow rate
-                        errFlag = false;
-                        thisFurnace.MaxSuppCoilFluidFlow =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", ReheatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the ReHeat Coil Inlet Node
-                        errFlag = false;
-                        ReheatCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", ReheatingCoilName, errFlag);
-                        thisFurnace.SuppCoilAirInletNode = ReheatCoilInletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the ReHeat Coil Outlet Node
-                        errFlag = false;
-                        ReheatCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", ReheatingCoilName, errFlag);
-                        thisFurnace.SuppCoilAirOutletNode = ReheatCoilOutletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
-
+                    } else {
+                        furnace.SuppCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, furnace.SuppCoilNum);
+                        furnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.SuppCoilNum);
+                        furnace.SuppCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                        furnace.SuppCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
                         // check if user has also used a water coil controller, which they should not do
                         errFlag = false;
-                        HVACControllers::CheckCoilWaterInletNode(state, thisFurnace.CoilControlNode, errFlag);
+                        HVACControllers::CheckCoilWaterInletNode(state, furnace.SuppCoilControlNode, errFlag);
                         if (!errFlag) { // then did find a controller so that is bad
                             ShowSevereError(state,
-                                            format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, thisFurnace.Name));
+                                            format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, furnace.Name));
                             ShowContinueError(state, "Hot water coils are controlled directly by unitary and furnace systems.");
                             ShowContinueError(state, "No water coil controller should be input for the coil.");
                             ErrorsFound = true;
                         }
                     }
 
-                } else if (Util::SameString(ReheatingCoilType, "Coil:Heating:Steam")) {
-                    thisFurnace.SuppHeatCoilType_Num = HVAC::Coil_HeatingSteam;
-                    ValidateComponent(state, ReheatingCoilType, ReheatingCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                } else if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
+                    furnace.SuppCoilNum = SteamCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                    if (furnace.SuppCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(16), furnace.SuppCoilName);
                         ErrorsFound = true;
-                    } else { // mine data from heating coil object
-
-                        errFlag = false;
-                        thisFurnace.SuppHeatCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", ReheatingCoilName, errFlag);
-                        if (thisFurnace.SuppHeatCoilIndex == 0) {
-                            ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(11), ReheatingCoilName));
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Heating Coil steam inlet node number
-                        errFlag = false;
-                        thisFurnace.SuppCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", ReheatingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
-
+                    } else {
+                        furnace.SuppCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, furnace.SuppCoilNum);
                         // Get the Heating Coil steam max volume flow rate
-                        thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag);
-                        if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) {
-                            SteamDensity =
-                                Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, getAirLoopHVACHeatCoolInput);
-                            thisFurnace.MaxSuppCoilFluidFlow =
-                                SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity;
+                        furnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.SuppCoilNum);
+                        if (furnace.MaxSuppCoilFluidFlow > 0.0) {
+                            furnace.MaxSuppCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, getAirLoopHVACHeatCoolInput);
                         }
 
-                        // Get the Heating Coil Inlet Node
-                        errFlag = false;
-                        ReheatCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisFurnace.SuppHeatCoilIndex, ReheatingCoilName, errFlag);
-                        thisFurnace.SuppCoilAirInletNode = ReheatCoilInletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Heating Coil Outlet Node
-                        errFlag = false;
-                        ReheatCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisFurnace.SuppHeatCoilIndex, ReheatingCoilName, errFlag);
-                        thisFurnace.SuppCoilAirOutletNode = ReheatCoilOutletNode;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                            ErrorsFound = true;
-                        }
+                        furnace.SuppCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                        furnace.SuppCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
                     }
 
                 } else { // Illegal heating coil
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(15), Alphas(15)));
+                    ShowSevereInvalidKey(state, eoh, cAlphaFields(15), Alphas(15));
                     ErrorsFound = true;
-                } // IF (Furnace(FurnaceNum)%SuppHeatCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
+                } // IF (Furnace(FurnaceNum)%SuppCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
 
             } // IF(.NOT. lAlphaBlanks(15))THEN
 
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
 
-                if (FanInletNode != thisFurnace.FurnaceInletNodeNum) {
-                    ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                    if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
-                        ShowContinueError(
-                            state, "When a blow through fan is specified, the fan inlet node name must be the same as the furnace inlet node name.");
-                        ShowContinueError(state, format("...Fan inlet node name     = {}", state.dataLoopNodes->NodeID(FanInletNode)));
-                        ShowContinueError(state,
-                                          format("...Furnace inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                if (furnace.FanInletNode != furnace.FurnaceInletNode) {
+                    if (furnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
+                        ShowSevereCustom(state, eoh, 
+                                         "When a blow through fan is specified, the fan inlet node name must be the same as the furnace inlet node name.");
+                        ShowContinueError(state, format("...Fan inlet node name     = {}", s_node->NodeID(furnace.FanInletNode)));
+                        ShowContinueError(state, format("...Furnace inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     } else {
-                        ShowContinueError(
-                            state,
+                        ShowSevereCustom(state, eoh,
                             "When a blow through fan is specified, the fan inlet node name must be the same as the unitary system inlet node name.");
-                        ShowContinueError(state, format("...Fan inlet node name           = {}", state.dataLoopNodes->NodeID(FanInletNode)));
-                        ShowContinueError(
-                            state, format("...UnitarySystem inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                        ShowContinueError(state, format("...Fan inlet node name           = {}", s_node->NodeID(furnace.FanInletNode)));
+                        ShowContinueError(state, format("...UnitarySystem inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     }
                     ErrorsFound = true;
                 }
-                if (thisFurnace.CoolingCoilUpstream) {
-                    if (FanOutletNode != CoolingCoilInletNode) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(
-                            state,
+                if (furnace.CoolCoilUpstream) {
+                    if (furnace.FanOutletNode != furnace.CoolCoilAirInletNode) {
+                        ShowSevereCustom(state, eoh, 
                             "When a blow through fan is specified, the fan outlet node name must be the same as the cooling coil inlet node name.");
-                        ShowContinueError(state, format("...Fan outlet node name         = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                        ShowContinueError(state, format("...Cooling coil inlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
+                        ShowContinueError(state, format("...Fan outlet node name         = {}", s_node->NodeID(furnace.FanOutletNode)));
+                        ShowContinueError(state, format("...Cooling coil inlet node name = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
                         ErrorsFound = true;
                     }
-                    if (CoolingCoilOutletNode != HeatingCoilInletNode) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
-                        ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                        ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                    if (furnace.CoolCoilAirOutletNode != furnace.HeatCoilAirInletNode) {
+                        ShowSevereCustom(state, eoh,
+                                       "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
+                        ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                        ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                         ErrorsFound = true;
                     }
-                    if ((thisFurnace.Humidistat && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) ||
-                        ReheatCoilInletNode > 0) {
-                        if (HeatingCoilOutletNode != ReheatCoilInletNode) {
-                            ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                            ShowContinueError(state,
+                    if ((furnace.Humidistat && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) ||
+                        furnace.SuppCoilAirInletNode > 0) {
+                        if (furnace.HeatCoilAirOutletNode != furnace.SuppCoilAirInletNode) {
+                            ShowSevereCustom(state, eoh,
                                               "When a blow through fan is specified, the heating coil outlet node name must be the same as the "
                                               "reheat coil inlet node name.");
-                            ShowContinueError(state,
-                                              format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                            ShowContinueError(state,
-                                              format("...Reheat coil inlet node name   = {}", state.dataLoopNodes->NodeID(ReheatCoilInletNode)));
+                            ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                            ShowContinueError(state, format("...Reheat coil inlet node name   = {}", s_node->NodeID(furnace.SuppCoilAirInletNode)));
                             ErrorsFound = true;
                         }
-                        if (ReheatCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                            ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                            if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
-                                ShowContinueError(state, "The reheat coil outlet node name must be the same as the furnace outlet node name.");
-                                ShowContinueError(state,
-                                                  format("...Reheat coil outlet node name = {}", state.dataLoopNodes->NodeID(ReheatCoilOutletNode)));
-                                ShowContinueError(
-                                    state,
-                                    format("...Furnace outlet node name     = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                        if (furnace.SuppCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                            if (furnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
+                                ShowSevereCustom(state, eoh, "The reheat coil outlet node name must be the same as the furnace outlet node name.");
+                                ShowContinueError(state, format("...Reheat coil outlet node name = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
+                                ShowContinueError(state, format("...Furnace outlet node name     = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                             } else {
                                 ShowContinueError(state, "The reheat coil outlet node name must be the same as the unitary system outlet node name.");
-                                ShowContinueError(
-                                    state, format("...Reheat coil outlet node name   = {}", state.dataLoopNodes->NodeID(ReheatCoilOutletNode)));
-                                ShowContinueError(
-                                    state,
-                                    format("...UnitarySystem outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                                ShowContinueError(state, format("...Reheat coil outlet node name   = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
+                                ShowContinueError(state, format("...UnitarySystem outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                             }
                             ErrorsFound = true;
                         }
                     } else { // IF((Furnace(FurnaceNum)%Humidistat ...
                         // Heating coil outlet node name must be the same as the furnace outlet node name
-                        if (HeatingCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                            ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                            if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
-                                ShowContinueError(state,
-                                                  "When a blow through fan is specified, the heating coil outlet node name must be the same as the "
-                                                  "furnace outlet node name.");
-                                ShowContinueError(
-                                    state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                                ShowContinueError(
-                                    state,
-                                    format("...Furnace outlet node name      = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                        if (furnace.HeatCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                            if (furnace.type == HVAC::UnitarySysType::Furnace_HeatOnly) {
+                                ShowSevereCustom(state, eoh, 
+                                    "When a blow through fan is specified, the heating coil outlet node name must be the same as the "
+                                                 "furnace outlet node name.");
+                                ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                                ShowContinueError(state, format("...Furnace outlet node name      = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                             } else {
-                                ShowContinueError(state,
+                                ShowSevereCustom(state, eoh,
                                                   "When a blow through fan is specified, the heating coil outlet node name must be the same as the "
                                                   "unitary system outlet node name.");
-                                ShowContinueError(
-                                    state, format("...Heating coil outlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                                ShowContinueError(
-                                    state,
-                                    format("...UnitarySystem outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                                ShowContinueError(state, format("...Heating coil outlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                                ShowContinueError(state, format("...UnitarySystem outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                             }
                             ErrorsFound = true;
                         }
                     }
                 } else { // IF(Furnace(FurnaceNum)%CoolingCoilUpstream)THEN
-                    if (FanOutletNode != HeatingCoilInletNode) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(
-                            state,
+                    if (furnace.FanOutletNode != furnace.HeatCoilAirInletNode) {
+                        ShowSevereCustom(state, eoh, 
                             "When a blow through fan is specified, the fan outlet node name must be the same as the heating coil inlet node name.");
-                        ShowContinueError(state, format("...Fan outlet node name         = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                        ShowContinueError(state, format("...Heating coil inlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                        ShowContinueError(state, format("...Fan outlet node name         = {}", s_node->NodeID(furnace.FanOutletNode)));
+                        ShowContinueError(state, format("...Heating coil inlet node name = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                         ErrorsFound = true;
                     }
-                    if (HeatingCoilOutletNode != CoolingCoilInletNode) {
+                    if (furnace.HeatCoilAirOutletNode != furnace.CoolCoilAirInletNode) {
                         ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
                         ShowContinueError(state, "The heating coil outlet node name must be the same as the cooling coil inlet node name.");
-                        ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                        ShowContinueError(state, format("...Cooling coil inlet node name  = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
+                        ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                        ShowContinueError(state, format("...Cooling coil inlet node name  = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
                         ErrorsFound = true;
                     }
-                    if (CoolingCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
-                            ShowContinueError(state,
+                    if (furnace.CoolCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                        if (furnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
+                            ShowSevereCustom(state, eoh, 
                                               "When a blow through fan is specified, the cooling coil outlet node name must be the same as the "
                                               "furnace outlet node name.");
-                            ShowContinueError(state,
-                                              format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                            ShowContinueError(
-                                state,
-                                format("...Furnace outlet node name      = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                            ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                            ShowContinueError(state, format("...Furnace outlet node name      = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                         } else {
-                            ShowContinueError(state,
+                            ShowSevereCustom(state, eoh,
                                               "When a blow through fan is specified, the cooling coil outlet node name must be the same as the "
                                               "unitary system outlet node name.");
-                            ShowContinueError(state,
-                                              format("...Cooling coil outlet node name   = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                            ShowContinueError(
-                                state,
-                                format("...UnitarySystem outlet node name  = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                            ShowContinueError(state, format("...Cooling coil outlet node name   = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                            ShowContinueError(state, format("...UnitarySystem outlet node name  = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                         }
                         ErrorsFound = true;
                     }
@@ -2291,142 +1760,114 @@ namespace Furnaces {
 
             } else { // ELSE from IF(Furnace(FurnaceNum)%FanPlace .EQ. BlowThru)THEN
 
-                if (thisFurnace.CoolingCoilUpstream) {
-                    if (CoolingCoilInletNode != thisFurnace.FurnaceInletNodeNum) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
-                            ShowContinueError(state,
-                                              "When a draw through fan is specified, the cooling coil inlet node name must be the same as the "
-                                              "furnace inlet node name.");
-                            ShowContinueError(state,
-                                              format("...Cooling coil inlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
-                            ShowContinueError(
-                                state, format("...Furnace inlet node name      = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                if (furnace.CoolCoilUpstream) {
+                    if (furnace.CoolCoilAirInletNode != furnace.FurnaceInletNode) {
+                        if (furnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
+                            ShowSevereCustom(state, eoh, 
+                                             "When a draw through fan is specified, the cooling coil inlet node name must be the same as the "
+                                             "furnace inlet node name.");
+                            ShowContinueError(state, format("...Cooling coil inlet node name = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
+                            ShowContinueError(state, format("...Furnace inlet node name      = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                         } else {
-                            ShowContinueError(state,
-                                              "When a draw through fan is specified, the cooling coil inlet node name must be the same as the "
-                                              "unitary system inlet node name.");
-                            ShowContinueError(state,
-                                              format("...Cooling coil inlet node name  = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
-                            ShowContinueError(
-                                state, format("...UnitarySystem inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                           ShowSevereCustom(state, eoh,
+                                           "When a draw through fan is specified, the cooling coil inlet node name must be the same as the "
+                                           "unitary system inlet node name.");
+                            ShowContinueError(state, format("...Cooling coil inlet node name  = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
+                            ShowContinueError(state, format("...UnitarySystem inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                         }
                         ErrorsFound = true;
                     }
-                    if (CoolingCoilOutletNode != HeatingCoilInletNode) {
+                    if (furnace.CoolCoilAirOutletNode != furnace.HeatCoilAirInletNode) {
                         ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
                         ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
-                        ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                        ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                        ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                        ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                         ErrorsFound = true;
                     }
-                    if (HeatingCoilOutletNode != FanInletNode) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(
-                            state,
+                    if (furnace.HeatCoilAirOutletNode != furnace.FanInletNode) {
+                        ShowSevereCustom(state, eoh, 
                             "When a draw through fan is specified, the heating coil outlet node name must be the same as the fan inlet node name.");
-                        ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                        ShowContinueError(state, format("...Fan inlet node name           = {}", state.dataLoopNodes->NodeID(FanInletNode)));
+                        ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                        ShowContinueError(state, format("...Fan inlet node name           = {}", s_node->NodeID(furnace.FanInletNode)));
                         ErrorsFound = true;
                     }
-                    if ((thisFurnace.Humidistat && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) ||
-                        ReheatCoilInletNode > 0) {
-                        if (FanOutletNode != ReheatCoilInletNode) {
-                            ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                            ShowContinueError(state,
+                    if ((furnace.Humidistat && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) ||
+                        furnace.SuppCoilAirInletNode > 0) {
+                        if (furnace.FanOutletNode != furnace.SuppCoilAirInletNode) {
+                            ShowSevereCustom(state, eoh, 
                                               "When a draw through fan is specified, the fan outlet node name must be the same as the reheat coil "
                                               "inlet node name.");
-                            ShowContinueError(state, format("...Fan outlet node name        = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                            ShowContinueError(state, format("...Reheat coil inlet node name = {}", state.dataLoopNodes->NodeID(ReheatCoilInletNode)));
+                            ShowContinueError(state, format("...Fan outlet node name        = {}", s_node->NodeID(furnace.FanOutletNode)));
+                            ShowContinueError(state, format("...Reheat coil inlet node name = {}", s_node->NodeID(furnace.SuppCoilAirInletNode)));
                             ErrorsFound = true;
                         }
-                        if (ReheatCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                            ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                            if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
-                                ShowContinueError(state, "The reheat coil outlet node name must be the same as the furnace outlet node name.");
-                                ShowContinueError(state,
-                                                  format("...Reheat coil outlet node name = {}", state.dataLoopNodes->NodeID(ReheatCoilOutletNode)));
-                                ShowContinueError(
-                                    state,
-                                    format("...Furnace outlet node name     = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                        if (furnace.SuppCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                            if (furnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
+                                ShowSevereCustom(state, eoh, "The reheat coil outlet node name must be the same as the furnace outlet node name.");
+                                ShowContinueError(state, format("...Reheat coil outlet node name = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
+                                ShowContinueError(state, format("...Furnace outlet node name     = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                             } else {
                                 ShowContinueError(state, "The reheat coil outlet node name must be the same as the unitary system outlet node name.");
                                 ShowContinueError(
-                                    state, format("...Reheat coil outlet node name   = {}", state.dataLoopNodes->NodeID(ReheatCoilOutletNode)));
+                                    state, format("...Reheat coil outlet node name   = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
                                 ShowContinueError(
                                     state,
-                                    format("...UnitarySystem outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                                    format("...UnitarySystem outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                             }
                             ErrorsFound = true;
                         }
                     } else {
-                        if (FanOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                            ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                            ShowContinueError(state,
+                        if (furnace.FanOutletNode != furnace.FurnaceOutletNode) {
+                            ShowSevereCustom(state, eoh, 
                                               "When a draw through fan is specified, the fan outlet node name must be the same as the unitary system "
                                               "outlet node name.");
-                            ShowContinueError(state, format("...Fan outlet node name        = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                            ShowContinueError(
-                                state,
-                                format("...Unitary system outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                            ShowContinueError(state, format("...Fan outlet node name        = {}", s_node->NodeID(furnace.FanOutletNode)));
+                            ShowContinueError(state, format("...Unitary system outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                             ErrorsFound = true;
                         }
                     }
                 } else { // IF(Furnace(FurnaceNum)%CoolingCoilUpstream)THEN
-                    if (HeatingCoilInletNode != thisFurnace.FurnaceInletNodeNum) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
-                            ShowContinueError(state,
+                    if (furnace.HeatCoilAirInletNode != furnace.FurnaceInletNode) {
+                        if (furnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
+                            ShowSevereCustom(state, eoh,
                                               "When a draw through fan is specified, the heating coil inlet node name must be the same as the "
                                               "furnace inlet node name.");
-                            ShowContinueError(state,
-                                              format("...Heating coil inlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
-                            ShowContinueError(
-                                state, format("...Furnace inlet node name      = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                            ShowContinueError(state, format("...Heating coil inlet node name = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
+                            ShowContinueError(state, format("...Furnace inlet node name      = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                         } else {
-                            ShowContinueError(state,
-                                              "When a draw through fan is specified, the heating coil inlet node name must be the same as the "
-                                              "unitary system inlet node name.");
-                            ShowContinueError(state,
-                                              format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
-                            ShowContinueError(
-                                state, format("...UnitarySystem inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                            ShowSevereCustom(state, eoh, 
+                                             "When a draw through fan is specified, the heating coil inlet node name must be the same as the "
+                                             "unitary system inlet node name.");
+                            ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
+                            ShowContinueError(state, format("...UnitarySystem inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                         }
                         ErrorsFound = true;
                     }
-                    if (HeatingCoilOutletNode != CoolingCoilInletNode) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(state, "The heating coil outlet node name must be the same as the cooling coil inlet node name.");
-                        ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                        ShowContinueError(state, format("...Cooling coil inlet node name  = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
+                    if (furnace.HeatCoilAirOutletNode != furnace.CoolCoilAirInletNode) {
+                        ShowSevereCustom(state, eoh, "The heating coil outlet node name must be the same as the cooling coil inlet node name.");
+                        ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                        ShowContinueError(state, format("...Cooling coil inlet node name  = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
                         ErrorsFound = true;
                     }
-                    if (CoolingCoilOutletNode != FanInletNode) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(
-                            state,
+                    if (furnace.CoolCoilAirOutletNode != furnace.FanInletNode) {
+                        ShowSevereCustom(state, eoh, 
                             "When a draw through fan is specified, the cooling coil outlet node name must be the same as the fan inlet node name.");
-                        ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                        ShowContinueError(state, format("...Fan inlet node name           = {}", state.dataLoopNodes->NodeID(FanInletNode)));
+                        ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                        ShowContinueError(state, format("...Fan inlet node name           = {}", s_node->NodeID(furnace.FanInletNode)));
                         ErrorsFound = true;
                     }
-                    if (FanOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                        ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                        if (thisFurnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
-                            ShowContinueError(
-                                state,
-                                "When a draw through fan is specified, the fan outlet node name must be the same as the furnace outlet node name.");
-                            ShowContinueError(state, format("...Fan outlet node name     = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                            ShowContinueError(
-                                state, format("...Furnace outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                    if (furnace.FanOutletNode != furnace.FurnaceOutletNode) {
+                          if (furnace.type == HVAC::UnitarySysType::Furnace_HeatCool) {
+                            ShowSevereCustom(state, eoh, 
+                                           "When a draw through fan is specified, the fan outlet node name must be the same as the furnace outlet node name.");
+                            ShowContinueError(state, format("...Fan outlet node name     = {}", s_node->NodeID(furnace.FanOutletNode)));
+                            ShowContinueError(state, format("...Furnace outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                         } else {
-                            ShowContinueError(state,
+                            ShowSevereCustom(state, eoh,
                                               "When a draw through fan is specified, the fan outlet node name must be the same as the unitary system "
                                               "outlet node name.");
-                            ShowContinueError(state, format("...Fan outlet node name           = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                            ShowContinueError(
-                                state,
-                                format("...UnitarySystem outlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                            ShowContinueError(state, format("...Fan outlet node name           = {}", s_node->NodeID(furnace.FanOutletNode)));
+                            ShowContinueError(state, format("...UnitarySystem outlet node name = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                         }
                         ErrorsFound = true;
                     }
@@ -2439,48 +1880,48 @@ namespace Furnaces {
                                                  Alphas(1),
                                                  Alphas(7),
                                                  Alphas(8),
-                                                 state.dataLoopNodes->NodeID(FanInletNode),
-                                                 state.dataLoopNodes->NodeID(FanOutletNode));
+                                                 s_node->NodeID(furnace.FanInletNode),
+                                                 s_node->NodeID(furnace.FanOutletNode));
 
             // Add DX cooling coil to component sets array
-            if (thisFurnace.bIsIHP) {
+            if (furnace.isIHP) {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      Alphas(1),
                                                      Alphas(12),
                                                      Alphas(13) + " Cooling Coil",
-                                                     state.dataLoopNodes->NodeID(CoolingCoilInletNode),
-                                                     state.dataLoopNodes->NodeID(CoolingCoilOutletNode));
+                                                     s_node->NodeID(furnace.CoolCoilAirInletNode),
+                                                     s_node->NodeID(furnace.CoolCoilAirOutletNode));
             } else {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      Alphas(1),
                                                      Alphas(12),
                                                      Alphas(13),
-                                                     state.dataLoopNodes->NodeID(CoolingCoilInletNode),
-                                                     state.dataLoopNodes->NodeID(CoolingCoilOutletNode));
+                                                     s_node->NodeID(furnace.CoolCoilAirInletNode),
+                                                     s_node->NodeID(furnace.CoolCoilAirOutletNode));
             }
 
             // Add heating coil to component sets array
-            if (thisFurnace.bIsIHP) {
+            if (furnace.isIHP) {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      Alphas(1),
                                                      Alphas(10),
                                                      Alphas(11) + " Heating Coil",
-                                                     state.dataLoopNodes->NodeID(HeatingCoilInletNode),
-                                                     state.dataLoopNodes->NodeID(HeatingCoilOutletNode));
+                                                     s_node->NodeID(furnace.HeatCoilAirInletNode),
+                                                     s_node->NodeID(furnace.HeatCoilAirOutletNode));
             } else {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      Alphas(1),
                                                      Alphas(10),
                                                      Alphas(11),
-                                                     state.dataLoopNodes->NodeID(HeatingCoilInletNode),
-                                                     state.dataLoopNodes->NodeID(HeatingCoilOutletNode));
+                                                     s_node->NodeID(furnace.HeatCoilAirInletNode),
+                                                     s_node->NodeID(furnace.HeatCoilAirOutletNode));
             }
 
-            if (ReheatCoilInletNode > 0) {
+            if (furnace.SuppCoilAirInletNode > 0) {
 
                 // Add reheating coil to component sets array
                 BranchNodeConnections::SetUpCompSets(state,
@@ -2488,128 +1929,95 @@ namespace Furnaces {
                                                      Alphas(1),
                                                      Alphas(15),
                                                      Alphas(16),
-                                                     state.dataLoopNodes->NodeID(ReheatCoilInletNode),
-                                                     state.dataLoopNodes->NodeID(ReheatCoilOutletNode));
+                                                     s_node->NodeID(furnace.SuppCoilAirInletNode),
+                                                     s_node->NodeID(furnace.SuppCoilAirOutletNode));
             }
 
             // Set the furnace max outlet temperature
-            thisFurnace.DesignMaxOutletTemp = Numbers(1);
+            furnace.DesignMaxOutletTemp = Numbers(1);
 
-            thisFurnace.MaxCoolAirVolFlow = Numbers(2);
-            if (thisFurnace.MaxCoolAirVolFlow <= 0 && thisFurnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+            furnace.MaxCoolAirVolFlow = Numbers(2);
+            if (furnace.MaxCoolAirVolFlow <= 0 && furnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {:.7T}", cNumericFields(2), Numbers(2)));
                 ErrorsFound = true;
             }
 
-            thisFurnace.MaxHeatAirVolFlow = Numbers(3);
-            if (thisFurnace.MaxHeatAirVolFlow <= 0 && thisFurnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
+            furnace.MaxHeatAirVolFlow = Numbers(3);
+            if (furnace.MaxHeatAirVolFlow <= 0 && furnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {:.7T}", cNumericFields(3), Numbers(3)));
                 ErrorsFound = true;
             }
 
-            thisFurnace.MaxNoCoolHeatAirVolFlow = Numbers(4);
-            if (thisFurnace.MaxNoCoolHeatAirVolFlow < 0 && thisFurnace.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
+            furnace.MaxNoCoolHeatAirVolFlow = Numbers(4);
+            if (furnace.MaxNoCoolHeatAirVolFlow < 0 && furnace.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {:.7T}", cNumericFields(4), Numbers(4)));
                 ErrorsFound = true;
             }
 
             if (Numbers(2) != DataSizing::AutoSize && Numbers(3) != DataSizing::AutoSize && Numbers(4) != DataSizing::AutoSize) {
-                thisFurnace.DesignFanVolFlowRate = max(Numbers(2), Numbers(3), Numbers(4));
+                furnace.DesignFanVolFlowRate = max(Numbers(2), Numbers(3), Numbers(4));
             } else {
-                thisFurnace.DesignFanVolFlowRate = DataSizing::AutoSize;
+                furnace.DesignFanVolFlowRate = DataSizing::AutoSize;
             }
 
-            if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                errFlag = false;
-                if (thisFurnace.bIsIHP) {
-                    thisFurnace.CoolingCoilIndex = IntegratedHeatPump::GetCoilIndexIHP(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilName;
-                    thisFurnace.MaxCoolAirVolFlow =
-                        VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                } else {
-                    thisFurnace.MaxCoolAirVolFlow =
-                        VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                }
-
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-
-                thisFurnace.MaxNoCoolHeatAirVolFlow = min(thisFurnace.MaxHeatAirVolFlow, thisFurnace.MaxCoolAirVolFlow);
-                if (thisFurnace.MaxHeatAirVolFlow != DataSizing::AutoSize && thisFurnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
-                    thisFurnace.DesignFanVolFlowRate = max(thisFurnace.MaxHeatAirVolFlow, thisFurnace.MaxCoolAirVolFlow);
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                furnace.MaxNoCoolHeatAirVolFlow = min(furnace.MaxHeatAirVolFlow, furnace.MaxCoolAirVolFlow);
+                if (furnace.MaxHeatAirVolFlow != DataSizing::AutoSize && furnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+                    furnace.DesignFanVolFlowRate = max(furnace.MaxHeatAirVolFlow, furnace.MaxCoolAirVolFlow);
                 } else {
-                    thisFurnace.DesignFanVolFlowRate = DataSizing::AutoSize;
+                    furnace.DesignFanVolFlowRate = DataSizing::AutoSize;
                 }
             }
 
-            if (thisFurnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.ActualFanVolFlowRate < thisFurnace.MaxCoolAirVolFlow && thisFurnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+            if (furnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.ActualFanVolFlowRate < furnace.MaxCoolAirVolFlow && furnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                     ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(
                         state,
                         format("... air flow rate = {:.7T} in fan object {} is less than the maximum HVAC system air flow rate in cooling mode.",
-                               thisFurnace.ActualFanVolFlowRate,
+                               furnace.ActualFanVolFlowRate,
                                FanName));
                     ShowContinueError(state, format(" The {} is reset to the fan flow rate and the simulation continues.", cNumericFields(2)));
-                    thisFurnace.MaxCoolAirVolFlow = thisFurnace.ActualFanVolFlowRate;
-                    thisFurnace.DesignFanVolFlowRate = thisFurnace.ActualFanVolFlowRate;
+                    furnace.MaxCoolAirVolFlow = furnace.ActualFanVolFlowRate;
+                    furnace.DesignFanVolFlowRate = furnace.ActualFanVolFlowRate;
                 }
-                if (thisFurnace.ActualFanVolFlowRate < thisFurnace.MaxHeatAirVolFlow && thisFurnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
+                if (furnace.ActualFanVolFlowRate < furnace.MaxHeatAirVolFlow && furnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                     ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(
                         state,
                         format("... air flow rate = {:.7T} in fan object {} is less than the maximum HVAC system air flow rate in heating mode.",
-                               thisFurnace.ActualFanVolFlowRate,
+                               furnace.ActualFanVolFlowRate,
                                FanName));
                     ShowContinueError(state, format(" The {} is reset to the fan flow rate and the simulation continues.", cNumericFields(3)));
-                    thisFurnace.MaxHeatAirVolFlow = thisFurnace.ActualFanVolFlowRate;
-                    thisFurnace.DesignFanVolFlowRate = thisFurnace.ActualFanVolFlowRate;
+                    furnace.MaxHeatAirVolFlow = furnace.ActualFanVolFlowRate;
+                    furnace.DesignFanVolFlowRate = furnace.ActualFanVolFlowRate;
                 }
             }
 
-            if (thisFurnace.fanOpModeSched != nullptr) {
+            if (furnace.fanOpModeSched != nullptr) {
                 // Is this correct? 0.0 for max also?
-                if (!thisFurnace.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 0.0)) {
+                if (!furnace.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 0.0)) {
                     //           set air flow control mode:
                     //             UseCompressorOnFlow = operate at last cooling or heating air flow requested when compressor is off
                     //             UseCompressorOffFlow = operate at value specified by user
                     //           AirFlowControl only valid if fan opmode = ContFanCycComp
-                    if (thisFurnace.MaxNoCoolHeatAirVolFlow == 0.0) {
-                        thisFurnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
+                    if (furnace.MaxNoCoolHeatAirVolFlow == 0.0) {
+                        furnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
                     } else {
-                        thisFurnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOffFlow;
+                        furnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOffFlow;
                     }
                 }
             }
 
-            if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                errFlag = false;
-                if (thisFurnace.bIsIHP) {
-                    thisFurnace.CoolingCoilIndex = IntegratedHeatPump::GetCoilIndexIHP(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilName;
-                    thisFurnace.DesignCoolingCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                } else {
-                    thisFurnace.DesignCoolingCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                }
-
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            }
 
             // Set heating convergence tolerance
-            thisFurnace.HeatingConvergenceTolerance = 0.001;
+            furnace.HeatingConvergenceTolerance = 0.001;
 
             // Set cooling convergence tolerance
-            thisFurnace.CoolingConvergenceTolerance = 0.001;
+            furnace.CoolingConvergenceTolerance = 0.001;
 
             // set minimum outdoor temperature for compressor operation
             SetMinOATCompressor(state, FurnaceNum, cCurrentModuleObject, ErrorsFound);
@@ -2620,22 +2028,10 @@ namespace Furnaces {
         for (int HeatPumpNum = 1; HeatPumpNum <= NumHeatPump; ++HeatPumpNum) {
 
             CurrentModuleObject = "AirLoopHVAC:UnitaryHeatPump:AirToAir";
-            FanInletNode = 0;
-            FanOutletNode = 0;
-            CoolingCoilInletNode = 0;
-            CoolingCoilOutletNode = 0;
-            HeatingCoilInletNode = 0;
-            HeatingCoilOutletNode = 0;
-            SupHeatCoilInletNode = 0;
-            SupHeatCoilOutletNode = 0;
-            CoolingCoilType = ' ';
-            CoolingCoilName = ' ';
-            HeatingCoilType = ' ';
-            HeatingCoilName = ' ';
 
             FurnaceNum = NumHeatOnly + NumHeatCool + NumUnitaryHeatOnly + NumUnitaryHeatCool + HeatPumpNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-            thisFurnace.iterationMode.allocate(3);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+            furnace.iterationMode.allocate(3);
 
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      CurrentModuleObject,
@@ -2653,19 +2049,19 @@ namespace Furnaces {
             GlobalNames::VerifyUniqueInterObjectName(
                 state, state.dataFurnaces->UniqueFurnaceNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
 
-            thisFurnace.type = HVAC::UnitarySysType::Unitary_HeatPump_AirToAir;
-            thisFurnace.Name = Alphas(1);
+            furnace.type = HVAC::UnitarySysType::Unitary_HeatPump_AirToAir;
+            furnace.Name = Alphas(1);
 
-            ErrorObjectHeader eoh{routineName, CurrentModuleObject, thisFurnace.Name};
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, furnace.Name};
 
             if (lAlphaBlanks(2)) {
-                thisFurnace.availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((thisFurnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                furnace.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((furnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
                 ErrorsFound = true;
             }
 
-            thisFurnace.FurnaceInletNodeNum =
+            furnace.FurnaceInletNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     Alphas(3),
                                                     ErrorsFound,
@@ -2676,7 +2072,7 @@ namespace Furnaces {
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
 
-            thisFurnace.FurnaceOutletNodeNum =
+            furnace.FurnaceOutletNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     Alphas(4),
                                                     ErrorsFound,
@@ -2690,20 +2086,20 @@ namespace Furnaces {
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
             // Get the Controlling Zone or Location of the Furnace Thermostat
-            thisFurnace.ControlZoneNum = Util::FindItemInList(Alphas(5), state.dataHeatBal->Zone);
-            if (thisFurnace.ControlZoneNum == 0) {
+            furnace.ControlZoneNum = Util::FindItemInList(Alphas(5), state.dataHeatBal->Zone);
+            if (furnace.ControlZoneNum == 0) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(5), Alphas(5)));
                 ErrorsFound = true;
             }
 
             // Get the node number for the zone with the thermostat
-            if (thisFurnace.ControlZoneNum > 0) {
+            if (furnace.ControlZoneNum > 0) {
                 AirNodeFound = false;
                 AirLoopFound = false;
-                int ControlledZoneNum = thisFurnace.ControlZoneNum;
+                int ControlledZoneNum = furnace.ControlZoneNum;
                 //             Find the controlled zone number for the specified thermostat location
-                thisFurnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
+                furnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
                 //             Determine if furnace is on air loop served by the thermostat location specified
                 for (int zoneInNode = 1; zoneInNode <= state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).NumInletNodes; ++zoneInNode) {
                     int AirLoopNumber = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNodeAirLoopNum(zoneInNode);
@@ -2719,17 +2115,17 @@ namespace Furnaces {
                                         CurrentModuleObject))
                                     continue;
                                 AirLoopFound = true;
-                                thisFurnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
+                                furnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
                                 break;
                             }
                             if (AirLoopFound) break;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumTempControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumComfortControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                     }
@@ -2754,424 +2150,262 @@ namespace Furnaces {
             // Get fan data
             FanName = Alphas(7);
 
-            thisFurnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(6)));
+            furnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(6)));
 
-            if (thisFurnace.fanType == HVAC::FanType::OnOff || thisFurnace.fanType == HVAC::FanType::Constant) {
+            if (furnace.fanType == HVAC::FanType::OnOff || furnace.fanType == HVAC::FanType::Constant) {
 
-                if ((thisFurnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
+                if ((furnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
                     ShowSevereItemNotFound(state, eoh, cAlphaFields(7), FanName);
                     ErrorsFound = true;
                 } else {
-                    auto *fan = state.dataFans->fans(thisFurnace.FanIndex);
-                    FanInletNode = fan->inletNodeNum;
-                    FanOutletNode = fan->outletNodeNum;
-                    thisFurnace.fanAvailSched = fan->availSched;
-                    thisFurnace.ActualFanVolFlowRate = fan->maxAirFlowRate;
+                    auto *fan = state.dataFans->fans(furnace.FanIndex);
+                    furnace.FanInletNode = fan->inletNodeNum;
+                    furnace.FanOutletNode = fan->outletNodeNum;
+                    furnace.fanAvailSched = fan->availSched;
+                    furnace.ActualFanVolFlowRate = fan->maxAirFlowRate;
                 }
             }
 
             // Get heating coil type and name data
-            HeatingCoilType = Alphas(8);
-            HeatingCoilName = Alphas(9);
-
-            errFlag = false;
-
-            if (Util::SameString(HeatingCoilType, "COIL:HEATING:DX:VARIABLESPEED") ||
-                Util::SameString(HeatingCoilType, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) {
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingAirToAirVariableSpeed;
-                if (Util::SameString(HeatingCoilType, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) thisFurnace.bIsIHP = true;
-            } else {
-                thisFurnace.HeatingCoilType_Num = DXCoils::GetCoilTypeNum(state, HeatingCoilType, HeatingCoilName, errFlag);
-            }
-
-            if (errFlag) {
-                ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                ErrorsFound = true;
+            furnace.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(8)));
+            furnace.HeatCoilName = Alphas(9);
+
+            if (Util::SameString(Alphas(8), "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) {
+                furnace.isIHP = true;
+                furnace.ihpName = furnace.HeatCoilName;
+                furnace.ihpNum = IntegratedHeatPump::GetIHPIndex(state, furnace.ihpName);
+                if (furnace.ihpNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), furnace.ihpName);
+                    ErrorsFound = true;
+                } else {
+                    // HeatCoilName and HeatCoilType now reference the
+                    // VariableSpeedCoil in the IHP, not the enclosing
+                    // IHP
+                    furnace.heatCoilType = HVAC::CoilType::HeatingDXVariableSpeed;
+                    furnace.HeatCoilName = state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).SHCoilName;
+                }
             }
 
-            if (thisFurnace.HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
+                furnace.HeatCoilNum = DXCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), furnace.HeatCoilName);
                     ErrorsFound = true;
-
-                } else { // mine data from DX heating coil
-
-                    DXCoils::GetDXCoilIndex(state, HeatingCoilName, thisFurnace.HeatingCoilIndex, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...occurs {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil Node Names
-                    errFlag = false;
-                    HeatingCoilInletNode = DXCoils::GetCoilInletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    HeatingCoilOutletNode = DXCoils::GetCoilOutletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the design heating capacity
-                    errFlag = false;
-                    thisFurnace.DesignHeatingCapacity = DXCoils::GetCoilCapacity(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} ={}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                } // IF (IsNotOK) THEN
-            } else if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                } else {
+                    furnace.HeatCoilAirInletNode = DXCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = DXCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
+                    furnace.DesignHeatingCapacity = DXCoils::GetCoilCapacity(state, furnace.HeatCoilNum);
+                }
+                
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+                // At this point, it shouldn't matter whether the coil is embedded in an IHP or not
+                furnace.HeatCoilNum = VariableSpeedCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), furnace.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    if (thisFurnace.bIsIHP) {
-                        thisFurnace.HeatingCoilIndex = IntegratedHeatPump::GetCoilIndexIHP(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        IHPCoilIndex = thisFurnace.HeatingCoilIndex;
-                        IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(IHPCoilIndex).SHCoilName;
-                        HeatingCoilInletNode =
-                            VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, "COIL:HEATING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                        HeatingCoilOutletNode =
-                            VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, "COIL:HEATING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                    } else {
-                        thisFurnace.HeatingCoilIndex =
-                            VariableSpeedCoils::GetCoilIndexVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        HeatingCoilInletNode = VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                        HeatingCoilOutletNode = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    }
+                    furnace.HeatCoilAirInletNode = VariableSpeedCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = VariableSpeedCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
+                    furnace.DesignHeatingCapacity = VariableSpeedCoils::GetCoilCapacity(state, furnace.HeatCoilNum);
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(8), Alphas(8)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(8), Alphas(8));
                 ErrorsFound = true;
             }
 
             // Get Cooling Coil Information if available
-            CoolingCoilType = Alphas(10);
-            CoolingCoilName = Alphas(11);
-
-            if (Util::SameString(CoolingCoilType, "COIL:COOLING:DX:VARIABLESPEED") ||
-                Util::SameString(CoolingCoilType, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) {
-                thisFurnace.CoolingCoilType_Num = HVAC::Coil_CoolingAirToAirVariableSpeed;
-                if (Util::SameString(CoolingCoilType, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) thisFurnace.bIsIHP = true;
-            }
-
-            ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-
-            if (IsNotOK) {
-                ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                ErrorsFound = true;
-
-            } else { // mine data from DX cooling coil
-
-                errFlag = false;
-                PrintMessage = false;
-
-                if (thisFurnace.CoolingCoilType_Num != HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    thisFurnace.CoolingCoilType_Num = DXCoils::GetCoilTypeNum(state, CoolingCoilType, CoolingCoilName, errFlag, PrintMessage);
-                }
-
-                // If coil type not found, check to see if a HX assisted cooling coil is used.
-                if (thisFurnace.CoolingCoilType_Num == 0) {
-                    errFlag = false;
-                    PrintMessage = false;
-                    thisFurnace.CoolingCoilType_Num =
-                        HVACHXAssistedCoolingCoil::GetCoilGroupTypeNum(state, CoolingCoilType, CoolingCoilName, errFlag, PrintMessage);
-                }
-
-                if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-
-                    // Get the cooling coil node numbers
-                    errFlag = false;
-                    DXCoils::GetDXCoilIndex(state, CoolingCoilName, thisFurnace.CoolingCoilIndex, errFlag);
-                    CoolingCoilInletNode = DXCoils::GetCoilInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode = DXCoils::GetCoilOutletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the DX cooling coil design capacity
-                    errFlag = false;
-                    thisFurnace.DesignCoolingCapacity = DXCoils::GetCoilCapacity(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                } else if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-
-                    // Get the cooling coil node numbers
-                    errFlag = false;
-                    HVACHXAssistedCoolingCoil::GetHXDXCoilIndex(state, CoolingCoilName, thisFurnace.CoolingCoilIndex, errFlag);
-                    CoolingCoilInletNode = HVACHXAssistedCoolingCoil::GetCoilInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode = HVACHXAssistedCoolingCoil::GetCoilOutletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
+            furnace.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(10)));
+            furnace.CoolCoilName = Alphas(11);
 
-                    // Get the heat exchanger assisted cooling coil design capacity
-                    errFlag = false;
-                    thisFurnace.DesignCoolingCapacity = HVACHXAssistedCoolingCoil::GetCoilCapacity(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    }
-
-                    // get the actual index to the DX cooling coil object
-                    DXCoilIndex = HVACHXAssistedCoolingCoil::GetActualDXCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
-                    thisFurnace.ActualDXCoilIndexForHXAssisted = DXCoilIndex;
-
-                } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    // BOS ADDED, AUG/2012, VARIIABLE SPEED DX COOLING COIL
-                    //  Furnace(FurnaceNum)%DXCoolCoilType = 'COIL:COOLING:DX:VARIABLESPEED'
-                    //  Furnace(FurnaceNum)%DXCoolCoilName = CoolingCoilName
-                    ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-                    } else {
-                        errFlag = false;
-                        if (thisFurnace.bIsIHP) {
-                            thisFurnace.CoolingCoilIndex = IntegratedHeatPump::GetCoilIndexIHP(state, CoolingCoilType, CoolingCoilName, errFlag);
-                            IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilName;
-                        } else {
-                            thisFurnace.CoolingCoilIndex =
-                                VariableSpeedCoils::GetCoilIndexVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                            IHPCoilName = CoolingCoilName;
-                        }
-
-                        if (errFlag) {
-                            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        if (thisFurnace.bIsIHP) {
-                            CoolingCoilInletNode =
-                                VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                            CoolingCoilOutletNode =
-                                VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                            thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, IHPCoilName, errFlag);
-                        } else {
-                            CoolingCoilInletNode =
-                                VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                            CoolingCoilOutletNode =
-                                VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                            thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, CoolingCoilName, errFlag);
-                        }
+            if (Util::SameString(Alphas(10), "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE")) {
 
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-                    }
-                } else {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(10), Alphas(10)));
+                // Is this a legitimate check? Both heating and cooling colis have to be the same integrated heat pump?
+                if (!furnace.isIHP) { 
+                    ShowSevereCustom(state, eoh, "Cooling Coil is an integrated heat pump, but heating coil is not.");
+                    ErrorsFound = true;
+                } else if (!Util::SameString(furnace.CoolCoilName, furnace.ihpName)) {
+                    ShowSevereCustom(state, eoh, "Cooling Coil and cooling coil name different integrated heat pumps.");
                     ErrorsFound = true;
+                } else {
+                    furnace.coolCoilType = HVAC::CoilType::CoolingDXVariableSpeed;
                 }
             }
-
-            if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed &&
-                thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                // Furnace(FurnaceNum)%WatertoAirHPType = WatertoAir_VarSpeedEquationFit
-                if (thisFurnace.bIsIHP) {
-                    VariableSpeedCoils::SetVarSpeedCoilData(state,
-                                                            state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilIndex,
-                                                            ErrorsFound,
-                                                            _,
-                                                            state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SHCoilIndex);
+            
+            // If coil type not found, check to see if a HX assisted cooling coil is used.
+            // Is this actually needed?
+#ifdef GET_OUT            
+            if (furnace.coolCoilType == HVAC::CoilType::Invalid) {
+                int hxCoilIndex = HXAssistCoil::GetHXCoilIndex(state, furnace.CoolCoilName);
+                if (hxCoilIndex == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), furnace.CoolCoilName);
+                    ErrorsFound = true;
                 } else {
-                    VariableSpeedCoils::SetVarSpeedCoilData(state, thisFurnace.CoolingCoilIndex, ErrorsFound, _, thisFurnace.HeatingCoilIndex);
+                    furnace.coolCoilType = HXAssistCoil::GetHXCoilType(state, furnace.CoolCoilName);
                 }
             }
-
-            // Get supplemental heating coil information
-            SuppHeatCoilType = Alphas(12);
-            SuppHeatCoilName = Alphas(13);
-            thisFurnace.SuppHeatCoilType = SuppHeatCoilType;
-            thisFurnace.SuppHeatCoilName = SuppHeatCoilName;
-            errFlag = false;
-            if (Util::SameString(SuppHeatCoilType, "Coil:Heating:Fuel") || Util::SameString(SuppHeatCoilType, "Coil:Heating:Electric")) {
-
-                thisFurnace.SuppHeatCoilType_Num = HeatingCoils::GetHeatingCoilTypeNum(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+#endif // GET_OUT
+            
+            // Single-speed DX Coil
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+                furnace.CoolCoilNum = DXCoils::GetCoilIndex(state, furnace.CoolCoilName);
+                if (furnace.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.CoolCoilName);
                     ErrorsFound = true;
                 } else {
-                    IsNotOK = false;
-                    ValidateComponent(state, SuppHeatCoilType, SuppHeatCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("In {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-
-                    } else { // mine data from the supplemental heating coil
-
-                        HeatingCoils::GetCoilIndex(state, SuppHeatCoilName, thisFurnace.SuppHeatCoilIndex, IsNotOK);
-                        if (IsNotOK) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Supplemental Heating Coil Inlet Node Number
-                        errFlag = false;
-                        SupHeatCoilInletNode = HeatingCoils::GetCoilInletNode(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Supplemental Heating Coil Outlet Node Number
-                        errFlag = false;
-                        SupHeatCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the supplemental heating coil design capacity
-                        errFlag = false;
-                        thisFurnace.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                    } // IF (IsNotOK) THEN
-                }
-            } else if (Util::SameString(SuppHeatCoilType, "Coil:Heating:Water")) {
-                thisFurnace.SuppHeatCoilType_Num = HVAC::Coil_HeatingWater;
-                ValidateComponent(state, SuppHeatCoilType, SuppHeatCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                    furnace.CoolCoilAirInletNode = DXCoils::GetCoilAirInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = DXCoils::GetCoilAirOutletNode(state, furnace.CoolCoilNum);
+                    furnace.DesignCoolingCapacity = DXCoils::GetCoilCapacity(state, furnace.CoolCoilNum);
+                    furnace.CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(state, furnace.CoolCoilNum);
+                }
+
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                // hxCoolCoil are the HXAssisted object parameters
+                // CoolCoil variables become the embedded DXCoil parameters
+                furnace.CoolCoilNum = HXAssistCoil::GetCoilIndex(state, furnace.CoolCoilName);
+                if (furnace.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.CoolCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    // Get the Heating Coil water Inlet or control Node number
-                    errFlag = false;
-                    thisFurnace.SuppCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil hot water max volume flow rate
-                    errFlag = false;
-                    thisFurnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil Inlet Node
-                    errFlag = false;
-                    SupHeatCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirInletNode = SupHeatCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil Outlet Node
-                    errFlag = false;
-                    SupHeatCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirOutletNode = SupHeatCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
+                } else {
+                    furnace.childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, furnace.CoolCoilNum);
+                    furnace.childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, furnace.CoolCoilNum);
+                    furnace.childCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(state, furnace.CoolCoilNum);
+                    
+                    furnace.CoolCoilAirInletNode = DXCoils::GetCoilAirInletNode(state, furnace.childCoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = DXCoils::GetCoilAirOutletNode(state, furnace.childCoolCoilNum);
+                    furnace.DesignCoolingCapacity = DXCoils::GetCoilCapacity(state, furnace.childCoolCoilNum);
+                
+                    furnace.CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(state, furnace.childCoolCoilNum);
+                }
+
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                // BOS ADDED, AUG/2012, VARIIABLE SPEED DX COOLING COIL
+                //  Furnace(FurnaceNum)%DXCoolCoilType = 'COIL:COOLING:DX:VARIABLESPEED'
+                //  Furnace(FurnaceNum)%DXCoolCoilName = CoolingCoilName
+                if (furnace.isIHP) {
+                    furnace.ihpNum = IntegratedHeatPump::GetIHPIndex(state, furnace.ihpName);
+                    if (furnace.ihpNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.ihpName);
                         ErrorsFound = true;
+                    } else {
+                        furnace.CoolCoilName = state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).SCCoilName;
+                        furnace.CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, furnace.CoolCoilName);
+                        if (furnace.CoolCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, format("{}.SCCoilName", furnace.ihpName), furnace.CoolCoilName);
+                            ErrorsFound = true;
+                        } 
                     }
-                    errFlag = false;
-                    HVACControllers::CheckCoilWaterInletNode(state, thisFurnace.CoilControlNode, errFlag);
-                    if (!errFlag) { // then did find a controller so that is bad
-                        ShowSevereError(state,
-                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, thisFurnace.Name));
-                        ShowContinueError(state, "Hot water coils are controlled directly by unitary and furnace systems.");
-                        ShowContinueError(state, "No water coil controller should be input for the coil.");
+                } else { // furnace.bIsHP
+                    furnace.CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, furnace.CoolCoilName);
+                    if (furnace.CoolCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.CoolCoilName);
                         ErrorsFound = true;
                     }
                 }
 
-            } else if (Util::SameString(SuppHeatCoilType, "Coil:Heating:Steam")) {
-                thisFurnace.SuppHeatCoilType_Num = HVAC::Coil_HeatingSteam;
-                ValidateComponent(state, SuppHeatCoilType, SuppHeatCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                } else { // mine data from heating coil object
+                // Shoud be properly set up whether this is an IHP or not
+                if (furnace.CoolCoilNum != 0) { 
+                    furnace.CoolCoilAirInletNode = VariableSpeedCoils::GetCoilAirInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = VariableSpeedCoils::GetCoilAirOutletNode(state, furnace.CoolCoilNum);
+                    furnace.CondenserNodeNum = VariableSpeedCoils::GetCoilCondenserInletNode(state, furnace.CoolCoilNum);
+                    furnace.DesignCoolingCapacity = VariableSpeedCoils::GetCoilCapacity(state, furnace.CoolCoilNum);
+                }
+            } else {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(10), Alphas(10));
+                ErrorsFound = true;
+            }
 
-                    errFlag = false;
-                    thisFurnace.SuppHeatCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", SuppHeatCoilName, errFlag);
-                    if (thisFurnace.SuppHeatCoilIndex == 0) {
-                        ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(12), SuppHeatCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed &&
+                furnace.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+                // Furnace(FurnaceNum)%WatertoAirHPType = WatertoAir_VarSpeedEquationFit
+                if (furnace.isIHP) {
+                    VariableSpeedCoils::SetCoilData(state,
+                                                    state.dataIntegratedHP->IntegratedHeatPumps(furnace.CoolCoilNum).SCCoilNum,
+                                                    _,
+                                                    state.dataIntegratedHP->IntegratedHeatPumps(furnace.CoolCoilNum).SHCoilNum);
+                } else {
+                    VariableSpeedCoils::SetCoilData(state, furnace.CoolCoilNum, _, furnace.HeatCoilNum);
+                }
+            }
 
-                    // Get the Heating Coil steam inlet node number
-                    errFlag = false;
-                    thisFurnace.SuppCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
+            // Get supplemental heating coil information
+            furnace.suppHeatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(12)));
+            furnace.SuppCoilName = Alphas(13);
 
-                    // Get the Heating Coil steam max volume flow rate
-                    thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag);
-                    if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) {
-                        SteamDensity =
-                            Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, getAirLoopHVACHeatCoolInput);
-                        thisFurnace.MaxSuppCoilFluidFlow =
-                            SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity;
-                    }
+            if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                furnace.suppHeatCoilType == HVAC::CoilType::HeatingElectric) {
 
-                    // Get the Heating Coil Inlet Node
-                    errFlag = false;
-                    SupHeatCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisFurnace.SuppHeatCoilIndex, SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirInletNode = SupHeatCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
+                furnace.SuppCoilNum = HeatingCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                if (furnace.SuppCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.SuppCoilName);
+                    ErrorsFound = true;
+                } else {
+                    furnace.SuppCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                    furnace.SuppCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
+                    furnace.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, furnace.SuppCoilNum);
+                }
 
-                    // Get the Heating Coil Outlet Node
-                    errFlag = false;
-                    SupHeatCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisFurnace.SuppHeatCoilIndex, SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirOutletNode = SupHeatCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
+            } else if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
+                furnace.SuppCoilNum = WaterCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                if (furnace.SuppCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.SuppCoilName);
+                    ErrorsFound = true;
+                } else {
+                    furnace.SuppCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, furnace.SuppCoilNum);
+                    furnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.SuppCoilNum);
+                    furnace.SuppCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                    furnace.SuppCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
+
+                    HVACControllers::CheckCoilWaterInletNode(state, furnace.SuppCoilControlNode, errFlag);
+                    if (!errFlag) { // then did find a controller so that is bad
+                        ShowSevereError(state,
+                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, furnace.Name));
+                        ShowContinueError(state, "Hot water coils are controlled directly by unitary and furnace systems.");
+                        ShowContinueError(state, "No water coil controller should be input for the coil.");
                         ErrorsFound = true;
                     }
                 }
 
+            } else if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
+                 furnace.SuppCoilNum = SteamCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                 if (furnace.SuppCoilNum == 0) {
+                     ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.SuppCoilName);
+                     ErrorsFound = true;
+                 } else {
+                     furnace.SuppCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, furnace.SuppCoilNum);
+                     furnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.SuppCoilNum);
+                     if (furnace.MaxSuppCoilFluidFlow > 0.0) {
+                         furnace.MaxSuppCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, getAirLoopHVACHeatCoolInput);
+                     }
+
+                     furnace.SuppCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                     furnace.SuppCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
+                 }
+
             } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(12), Alphas(12)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(12), Alphas(12));
                 ErrorsFound = true;
             } // IF (Furnace(FurnaceNum)%HeatingCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
 
-            thisFurnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(14)));
-            assert(thisFurnace.fanPlace != HVAC::FanPlace::Invalid);
+            furnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(14)));
+            assert(furnace.fanPlace != HVAC::FanPlace::Invalid);
 
             if (lAlphaBlanks(15)) {
-                thisFurnace.fanOp = HVAC::FanOp::Cycling;
-                if (thisFurnace.fanType != HVAC::FanType::OnOff) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, thisFurnace.Name));
+                furnace.fanOp = HVAC::FanOp::Cycling;
+                if (furnace.fanType != HVAC::FanType::OnOff) {
+                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, furnace.Name));
                     ShowContinueError(state, format("{} = {}", cAlphaFields(6), Alphas(6)));
                     ShowContinueError(state, format("Fan type must be Fan:OnOff when {} = Blank.", cAlphaFields(15)));
                     ErrorsFound = true;
                 }
-            } else if ((thisFurnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(15))) == nullptr) {
+            } else if ((furnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(15))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(15), Alphas(15));
                 ErrorsFound = true;
             }
 
-            if (thisFurnace.fanType == HVAC::FanType::Constant && thisFurnace.fanOpModeSched != nullptr &&
-                !thisFurnace.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
-                Sched::ShowSevereBadMinMax(
+            if (furnace.fanType == HVAC::FanType::Constant &&
+                furnace.fanOpModeSched != nullptr &&
+                !furnace.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
+                Sched::ShowSevereBadMinMax( // MAKE THIS INSANE FORMATTING STOP, I'M BEGGING YOU
                     state,
                     eoh,
                     cAlphaFields(15),
@@ -3188,26 +2422,24 @@ namespace Furnaces {
             if (Util::SameString(Alphas(16), "None") || Util::SameString(Alphas(16), "Multimode") || Util::SameString(Alphas(16), "CoolReheat")) {
                 AirNodeFound = false;
                 if (Util::SameString(Alphas(16), "Multimode")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::Multimode;
-                    thisFurnace.Humidistat = true;
-                    if (thisFurnace.CoolingCoilType_Num != HVAC::CoilDX_CoolingHXAssisted) {
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::Multimode;
+                    furnace.Humidistat = true;
+                    if (furnace.coolCoilType != HVAC::CoilType::CoolingDXHXAssisted) {
                         ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                         ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(16), Alphas(16)));
                         ShowContinueError(state, "Multimode control must be used with a Heat Exchanger Assisted Cooling Coil.");
                         ErrorsFound = true;
                     }
+                } else if (Util::SameString(Alphas(16), "CoolReheat")) {
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
+                    furnace.Humidistat = true;
+                } else if (Util::SameString(Alphas(16), "None")) {
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                    furnace.Humidistat = false;
                 }
-                if (Util::SameString(Alphas(16), "CoolReheat")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
-                    thisFurnace.Humidistat = true;
-                }
-                if (Util::SameString(Alphas(16), "None")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
-                    thisFurnace.Humidistat = false;
-                }
-                if (thisFurnace.Humidistat) {
+                if (furnace.Humidistat) {
                     for (HStatZoneNum = 1; HStatZoneNum <= state.dataZoneCtrls->NumHumidityControlZones; ++HStatZoneNum) {
-                        if (state.dataZoneCtrls->HumidityControlZone(HStatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                        if (state.dataZoneCtrls->HumidityControlZone(HStatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                         AirNodeFound = true;
                     }
                     if (!AirNodeFound) {
@@ -3223,114 +2455,83 @@ namespace Furnaces {
                     ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(16), Alphas(16)));
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.Humidistat = false;
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                    furnace.Humidistat = false;
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::None;
                 }
             }
 
             // Check node names for child components
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                if (FanInletNode != thisFurnace.FurnaceInletNodeNum) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(
-                        state,
-                        "When a blow through fan is specified, the fan inlet node name must be the same as the unitary system inlet node name.");
-                    ShowContinueError(state, format("...Fan inlet node name            = {}", state.dataLoopNodes->NodeID(FanInletNode)));
-                    ShowContinueError(state,
-                                      format("...Unitary system inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                if (furnace.FanInletNode != furnace.FurnaceInletNode) {
+                    ShowSevereCustom(state, eoh, "When a blow through fan is specified, the fan inlet node name must be the same as the unitary system inlet node name.");
+                    ShowContinueError(state, format("...Fan inlet node name            = {}", s_node->NodeID(furnace.FanInletNode)));
+                    ShowContinueError(state, format("...Unitary system inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     ErrorsFound = true;
                 }
-                if (FanOutletNode != CoolingCoilInletNode) {
+                if (furnace.FanOutletNode != furnace.CoolCoilAirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(
-                        state,
-                        "When a blow through fan is specified, the fan outlet node name must be the same as the cooling coil inlet node name.");
-                    ShowContinueError(state, format("...Fan outlet node name         = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                    ShowContinueError(state, format("...Cooling coil inlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
+                    ShowContinueError(state, "When a blow through fan is specified, the fan outlet node name must be the same as the cooling coil inlet node name.");
+                    ShowContinueError(state, format("...Fan outlet node name         = {}", s_node->NodeID(furnace.FanOutletNode)));
+                    ShowContinueError(state, format("...Cooling coil inlet node name = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (CoolingCoilOutletNode != HeatingCoilInletNode) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
-                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                if (furnace.CoolCoilAirOutletNode != furnace.HeatCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
+                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (HeatingCoilOutletNode != SupHeatCoilInletNode) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      "When a blow through fan is specified, the heating coil outlet node name must be the same as the supplemental "
-                                      "heating coil inlet node name.");
-                    ShowContinueError(
-                        state, format("...Heating coil outlet node name              = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                    ShowContinueError(
-                        state, format("...Supplemental heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(SupHeatCoilInletNode)));
+                if (furnace.HeatCoilAirOutletNode != furnace.SuppCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "When a blow through fan is specified, the heating coil outlet node name must be the same as the supplemental "
+                                     "heating coil inlet node name.");
+                    ShowContinueError(state, format("...Heating coil outlet node name              = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Supplemental heating coil inlet node name  = {}", s_node->NodeID(furnace.SuppCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (SupHeatCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      "The supplemental heating coil outlet node name must be the same as the unitary system outlet node name.");
-                    ShowContinueError(
-                        state, format("...Supplemental heating coil outlet node name = {}", state.dataLoopNodes->NodeID(SupHeatCoilOutletNode)));
-                    ShowContinueError(
-                        state,
-                        format("...Unitary system outlet node name            = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                if (furnace.SuppCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                    ShowSevereCustom(state, eoh, "The supplemental heating coil outlet node name must be the same as the unitary system outlet node name.");
+                    ShowContinueError(state, format("...Supplemental heating coil outlet node name = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Unitary system outlet node name            = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     ErrorsFound = true;
                 }
             } else {
-                if (CoolingCoilInletNode != thisFurnace.FurnaceInletNodeNum) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      "When a draw through fan is specified, the cooling coil inlet node name must be the same as the unitary system "
-                                      "inlet node name.");
-                    ShowContinueError(state, format("...Cooling coil inlet node name   = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
-                    ShowContinueError(state,
-                                      format("...Unitary system inlet node name = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
+                if (furnace.CoolCoilAirInletNode != furnace.FurnaceInletNode) {
+                    ShowSevereCustom(state, eoh, 
+                                     "When a draw through fan is specified, the cooling coil inlet node name must be the same as the unitary system "
+                                     "inlet node name.");
+                    ShowContinueError(state, format("...Cooling coil inlet node name   = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
+                    ShowContinueError(state, format("...Unitary system inlet node name = {}", s_node->NodeID(furnace.FurnaceInletNode)));
                     ErrorsFound = true;
                 }
-                if (CoolingCoilOutletNode != HeatingCoilInletNode) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
-                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                if (furnace.CoolCoilAirOutletNode != furnace.HeatCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
+                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (HeatingCoilOutletNode != FanInletNode) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(
-                        state,
-                        "When a draw through fan is specified, the heating coil outlet node name must be the same as the fan inlet node name.");
-                    ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                    ShowContinueError(state, format("...Fan inlet node name           = {}", state.dataLoopNodes->NodeID(FanInletNode)));
+                if (furnace.HeatCoilAirOutletNode != furnace.FanInletNode) {
+                    ShowSevereCustom(state, eoh, "When a draw through fan is specified, the heating coil outlet node name must be the same as the fan inlet node name.");
+                    ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Fan inlet node name           = {}", s_node->NodeID(furnace.FanInletNode)));
                     ErrorsFound = true;
                 }
-                if (FanOutletNode != SupHeatCoilInletNode) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      "When a draw through fan is specified, the fan outlet node name must be the same as the supplemental heating "
-                                      "coil inlet node name.");
-                    ShowContinueError(state,
-                                      format("...Fan outlet node name                       = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                    ShowContinueError(
-                        state, format("...Supplemental heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(SupHeatCoilInletNode)));
+                if (furnace.FanOutletNode != furnace.SuppCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "When a draw through fan is specified, the fan outlet node name must be the same as the supplemental heating "
+                                    "coil inlet node name.");
+                    ShowContinueError(state, format("...Fan outlet node name                       = {}", s_node->NodeID(furnace.FanOutletNode)));
+                    ShowContinueError(state, format("...Supplemental heating coil inlet node name  = {}", s_node->NodeID(furnace.SuppCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (SupHeatCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                    ShowSevereError(state, format("For {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      "The supplemental heating coil outlet node name must be the same as the unitary system outlet node name.");
-                    ShowContinueError(
-                        state, format("...Supplemental heating coil outlet node name = {}", state.dataLoopNodes->NodeID(SupHeatCoilOutletNode)));
-                    ShowContinueError(
-                        state,
-                        format("...Unitary system outlet node name            = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                if (furnace.SuppCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                    ShowSevereCustom(state, eoh, "The supplemental heating coil outlet node name must be the same as the unitary system outlet node name.");
+                    ShowContinueError(state, format("...Supplemental heating coil outlet node name = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Unitary system outlet node name            = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     ErrorsFound = true;
                 }
             }
 
             // Add component sets array
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
                 CompSetFanInlet = Alphas(3);
                 CompSetCoolInlet = "UNDEFINED";
             } else {
@@ -3340,14 +2541,14 @@ namespace Furnaces {
             BranchNodeConnections::SetUpCompSets(state, CurrentModuleObject, Alphas(1), Alphas(6), Alphas(7), CompSetFanInlet, "UNDEFINED");
 
             // Add DX cooling coil to component sets array
-            if (thisFurnace.bIsIHP) {
+            if (furnace.isIHP) {
                 BranchNodeConnections::SetUpCompSets(
                     state, CurrentModuleObject, Alphas(1), Alphas(10), Alphas(11) + " Cooling Coil", CompSetCoolInlet, "UNDEFINED");
             } else {
                 BranchNodeConnections::SetUpCompSets(state, CurrentModuleObject, Alphas(1), Alphas(10), Alphas(11), CompSetCoolInlet, "UNDEFINED");
             }
             // Add DX heating coil to component sets array
-            if (thisFurnace.bIsIHP) {
+            if (furnace.isIHP) {
                 BranchNodeConnections::SetUpCompSets(
                     state, CurrentModuleObject, Alphas(1), Alphas(8), Alphas(9) + " Heating Coil", "UNDEFINED", "UNDEFINED");
             } else {
@@ -3357,172 +2558,98 @@ namespace Furnaces {
             // Add supplemental heating coil to component sets array
             BranchNodeConnections::SetUpCompSets(state, CurrentModuleObject, Alphas(1), Alphas(12), Alphas(13), "UNDEFINED", Alphas(4));
 
-            thisFurnace.MaxCoolAirVolFlow = Numbers(1);
-            if (thisFurnace.MaxCoolAirVolFlow <= 0 && thisFurnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+            furnace.MaxCoolAirVolFlow = Numbers(1);
+            if (furnace.MaxCoolAirVolFlow <= 0 && furnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {:.7T}", cNumericFields(1), Numbers(1)));
                 ErrorsFound = true;
             }
 
-            thisFurnace.MaxHeatAirVolFlow = Numbers(2);
-            if (thisFurnace.MaxHeatAirVolFlow <= 0 && thisFurnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
+            furnace.MaxHeatAirVolFlow = Numbers(2);
+            if (furnace.MaxHeatAirVolFlow <= 0 && furnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {:.7T}", cNumericFields(2), Numbers(2)));
                 ErrorsFound = true;
             }
 
-            thisFurnace.MaxNoCoolHeatAirVolFlow = Numbers(3);
-            if (thisFurnace.MaxNoCoolHeatAirVolFlow < 0 && thisFurnace.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
+            furnace.MaxNoCoolHeatAirVolFlow = Numbers(3);
+            if (furnace.MaxNoCoolHeatAirVolFlow < 0 && furnace.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {:.7T}", cNumericFields(3), Numbers(3)));
                 ErrorsFound = true;
             }
 
-            if (thisFurnace.fanOpModeSched != nullptr) {
-                if (!thisFurnace.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 0.0)) { // Autodesk:Note Range is 0 to 0?
+            if (furnace.fanOpModeSched != nullptr) {
+                if (!furnace.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 0.0)) { // Autodesk:Note Range is 0 to 0?
                     //           set air flow control mode:
                     //             UseCompressorOnFlow = operate at last cooling or heating air flow requested when compressor is off
                     //             UseCompressorOffFlow = operate at value specified by user
                     //           AirFlowControl only valid if fan opmode = ContFanCycComp
-                    if (thisFurnace.MaxNoCoolHeatAirVolFlow == 0.0) {
-                        thisFurnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
+                    if (furnace.MaxNoCoolHeatAirVolFlow == 0.0) {
+                        furnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
                     } else {
-                        thisFurnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOffFlow;
+                        furnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOffFlow;
                     }
                 }
             }
 
             if (Numbers(1) != DataSizing::AutoSize && Numbers(2) != DataSizing::AutoSize && Numbers(3) != DataSizing::AutoSize) {
-                thisFurnace.DesignFanVolFlowRate = max(Numbers(1), Numbers(2), Numbers(3));
+                furnace.DesignFanVolFlowRate = max(Numbers(1), Numbers(2), Numbers(3));
             } else {
-                thisFurnace.DesignFanVolFlowRate = DataSizing::AutoSize;
+                furnace.DesignFanVolFlowRate = DataSizing::AutoSize;
             }
 
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                errFlag = false;
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+                // We've done the IHP thing, HeatCoilNum and CoolCoilNum should be properly set
+                furnace.MaxHeatAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRate(state, furnace.HeatCoilNum);
+                furnace.MaxCoolAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRate(state, furnace.CoolCoilNum);
 
-                if (thisFurnace.bIsIHP) {
-                    IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SHCoilName;
-                    thisFurnace.MaxHeatAirVolFlow =
-                        VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, "COIL:HEATING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                    IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilName;
-                    thisFurnace.MaxCoolAirVolFlow =
-                        VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
+                furnace.MaxNoCoolHeatAirVolFlow = min(furnace.MaxHeatAirVolFlow, furnace.MaxCoolAirVolFlow);
+                if (furnace.MaxHeatAirVolFlow != DataSizing::AutoSize && furnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+                    furnace.DesignFanVolFlowRate = max(furnace.MaxHeatAirVolFlow, furnace.MaxCoolAirVolFlow);
                 } else {
-                    thisFurnace.MaxHeatAirVolFlow =
-                        VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    thisFurnace.MaxCoolAirVolFlow =
-                        VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                }
-
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-
-                thisFurnace.MaxNoCoolHeatAirVolFlow = min(thisFurnace.MaxHeatAirVolFlow, thisFurnace.MaxCoolAirVolFlow);
-                if (thisFurnace.MaxHeatAirVolFlow != DataSizing::AutoSize && thisFurnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
-                    thisFurnace.DesignFanVolFlowRate = max(thisFurnace.MaxHeatAirVolFlow, thisFurnace.MaxCoolAirVolFlow);
-                } else {
-                    thisFurnace.DesignFanVolFlowRate = DataSizing::AutoSize;
+                    furnace.DesignFanVolFlowRate = DataSizing::AutoSize;
                 }
             }
 
-            if (thisFurnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.ActualFanVolFlowRate < thisFurnace.MaxCoolAirVolFlow && thisFurnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+            if (furnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.ActualFanVolFlowRate < furnace.MaxCoolAirVolFlow && furnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                     ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(
                         state,
                         format("... air flow rate = {:.7T} in fan object {} is less than the maximum HVAC system air flow rate in cooling mode.",
-                               thisFurnace.ActualFanVolFlowRate,
+                               furnace.ActualFanVolFlowRate,
                                FanName));
                     ShowContinueError(state, format(" The {} is reset to the fan flow rate and the simulation continues.", cNumericFields(1)));
-                    thisFurnace.MaxCoolAirVolFlow = thisFurnace.ActualFanVolFlowRate;
-                    thisFurnace.DesignFanVolFlowRate = thisFurnace.ActualFanVolFlowRate;
+                    furnace.MaxCoolAirVolFlow = furnace.ActualFanVolFlowRate;
+                    furnace.DesignFanVolFlowRate = furnace.ActualFanVolFlowRate;
                 }
-                if (thisFurnace.ActualFanVolFlowRate < thisFurnace.MaxHeatAirVolFlow && thisFurnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
+                if (furnace.ActualFanVolFlowRate < furnace.MaxHeatAirVolFlow && furnace.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                     ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(
                         state,
                         format("... air flow rate = {:.7T} in fan object {} is less than the maximum HVAC system air flow rate in heating mode.",
-                               thisFurnace.ActualFanVolFlowRate,
+                               furnace.ActualFanVolFlowRate,
                                FanName));
                     ShowContinueError(state, format(" The {} is reset to the fan flow rate and the simulation continues.", cNumericFields(2)));
-                    thisFurnace.MaxHeatAirVolFlow = thisFurnace.ActualFanVolFlowRate;
-                    thisFurnace.DesignFanVolFlowRate = thisFurnace.ActualFanVolFlowRate;
+                    furnace.MaxHeatAirVolFlow = furnace.ActualFanVolFlowRate;
+                    furnace.DesignFanVolFlowRate = furnace.ActualFanVolFlowRate;
                 }
             }
 
             // Set heating convergence tolerance
-            thisFurnace.HeatingConvergenceTolerance = 0.001;
-
-            //       Mine heatpump outdoor condenser node from DX coil object
-            errFlag = false;
-            if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-                thisFurnace.CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-            } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                if (thisFurnace.bIsIHP) {
-                    IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilName;
-                    thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, IHPCoilName, errFlag);
-                } else {
-                    thisFurnace.CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, CoolingCoilName, errFlag);
-                }
-            } else {
-                thisFurnace.CondenserNodeNum =
-                    DXCoils::GetCoilCondenserInletNode(state,
-                                                       "Coil:Cooling:DX:SingleSpeed",
-                                                       HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, CoolingCoilType, CoolingCoilName, errFlag),
-                                                       errFlag);
-            }
-            if (errFlag) {
-                ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                ErrorsFound = true;
-            }
-
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                errFlag = false;
-                if (thisFurnace.bIsIHP) {
-                    IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SHCoilName;
-                    thisFurnace.DesignHeatingCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, "Coil:Heating:DX:VariableSpeed", IHPCoilName, errFlag);
-                } else {
-                    thisFurnace.DesignHeatingCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                }
-
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            }
-
-            if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                errFlag = false;
-                if (thisFurnace.bIsIHP) {
-                    IHPCoilName = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilName;
-                    thisFurnace.DesignCoolingCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, "COIL:COOLING:DX:VARIABLESPEED", IHPCoilName, errFlag);
-                } else {
-                    thisFurnace.DesignCoolingCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                }
-
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            }
+            furnace.HeatingConvergenceTolerance = 0.001;
 
             // Set cooling convergence tolerance
-            thisFurnace.CoolingConvergenceTolerance = 0.001;
+            furnace.CoolingConvergenceTolerance = 0.001;
 
             // Set the furnace max outlet temperature
-            thisFurnace.DesignMaxOutletTemp = Numbers(4);
+            furnace.DesignMaxOutletTemp = Numbers(4);
 
             // Set maximum supply air temperature for supplemental heating coil
-            thisFurnace.MaxOATSuppHeat = Numbers(5);
+            furnace.MaxOATSuppHeat = Numbers(5);
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, HeatingCoilName, thisFurnace.MaxOATSuppHeat);
+                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, furnace.HeatCoilName, furnace.MaxOATSuppHeat);
 
             // set minimum outdoor temperature for compressor operation
             SetMinOATCompressor(state, FurnaceNum, cCurrentModuleObject, ErrorsFound);
@@ -3533,22 +2660,10 @@ namespace Furnaces {
         for (int HeatPumpNum = 1; HeatPumpNum <= NumWaterToAirHeatPump; ++HeatPumpNum) {
 
             CurrentModuleObject = "AirLoopHVAC:UnitaryHeatPump:WaterToAir";
-            FanInletNode = 0;
-            FanOutletNode = 0;
-            CoolingCoilInletNode = 0;
-            CoolingCoilOutletNode = 0;
-            HeatingCoilInletNode = 0;
-            HeatingCoilOutletNode = 0;
-            SupHeatCoilInletNode = 0;
-            SupHeatCoilOutletNode = 0;
-            CoolingCoilType = ' ';
-            CoolingCoilName = ' ';
-            HeatingCoilType = ' ';
-            HeatingCoilName = ' ';
 
             FurnaceNum = NumHeatOnly + NumHeatCool + NumUnitaryHeatOnly + NumUnitaryHeatCool + NumHeatPump + HeatPumpNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-            thisFurnace.iterationMode.allocate(3);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+            furnace.iterationMode.allocate(3);
 
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      CurrentModuleObject,
@@ -3566,19 +2681,19 @@ namespace Furnaces {
             GlobalNames::VerifyUniqueInterObjectName(
                 state, state.dataFurnaces->UniqueFurnaceNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
 
-            thisFurnace.type = HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir;
-            thisFurnace.Name = Alphas(1);
+            furnace.type = HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir;
+            furnace.Name = Alphas(1);
 
-            ErrorObjectHeader eoh{routineName, CurrentModuleObject, thisFurnace.Name};
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, furnace.Name};
 
             if (lAlphaBlanks(2)) {
-                thisFurnace.availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((thisFurnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                furnace.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((furnace.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
                 ErrorsFound = true;
             }
 
-            thisFurnace.FurnaceInletNodeNum =
+            furnace.FurnaceInletNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     Alphas(3),
                                                     ErrorsFound,
@@ -3589,7 +2704,7 @@ namespace Furnaces {
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
 
-            thisFurnace.FurnaceOutletNodeNum =
+            furnace.FurnaceOutletNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     Alphas(4),
                                                     ErrorsFound,
@@ -3603,20 +2718,20 @@ namespace Furnaces {
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
             // Get the Controlling Zone or Location of the Furnace Thermostat
-            thisFurnace.ControlZoneNum = Util::FindItemInList(Alphas(5), state.dataHeatBal->Zone);
-            if (thisFurnace.ControlZoneNum == 0) {
+            furnace.ControlZoneNum = Util::FindItemInList(Alphas(5), state.dataHeatBal->Zone);
+            if (furnace.ControlZoneNum == 0) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(5), Alphas(5)));
                 ErrorsFound = true;
             }
 
             // Get the node number for the zone with the thermostat
-            if (thisFurnace.ControlZoneNum > 0) {
+            if (furnace.ControlZoneNum > 0) {
                 AirNodeFound = false;
                 AirLoopFound = false;
-                int ControlledZoneNum = thisFurnace.ControlZoneNum;
+                int ControlledZoneNum = furnace.ControlZoneNum;
                 //             Find the controlled zone number for the specified thermostat location
-                thisFurnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
+                furnace.NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ZoneNode;
                 //             Determine if furnace is on air loop served by the thermostat location specified
                 for (int zoneInNode = 1; zoneInNode <= state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).NumInletNodes; ++zoneInNode) {
                     int AirLoopNumber = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNodeAirLoopNum(zoneInNode);
@@ -3632,17 +2747,17 @@ namespace Furnaces {
                                         CurrentModuleObject))
                                     continue;
                                 AirLoopFound = true;
-                                thisFurnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
+                                furnace.ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).InletNode(zoneInNode);
                                 break;
                             }
                             if (AirLoopFound) break;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumTempControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                         for (TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumComfortControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                            if (state.dataZoneCtrls->ComfortControlledZone(TstatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                             AirNodeFound = true;
                         }
                     }
@@ -3667,307 +2782,184 @@ namespace Furnaces {
             // Get fan data
             FanName = Alphas(7);
             errFlag = false;
-            thisFurnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(6)));
+            furnace.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(6)));
 
-            if (thisFurnace.fanType != HVAC::FanType::OnOff) {
+            if (furnace.fanType != HVAC::FanType::OnOff) {
                 ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(6), Alphas(6)));
                 ErrorsFound = true;
 
-            } else if ((thisFurnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
+            } else if ((furnace.FanIndex = Fans::GetFanIndex(state, FanName)) == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(7), FanName);
                 ErrorsFound = true;
 
             } else {
-                auto *fan = state.dataFans->fans(thisFurnace.FanIndex);
-                FanInletNode = fan->inletNodeNum;
-                FanOutletNode = fan->outletNodeNum;
-                thisFurnace.fanAvailSched = fan->availSched;
+                auto *fan = state.dataFans->fans(furnace.FanIndex);
+                furnace.FanInletNode = fan->inletNodeNum;
+                furnace.FanOutletNode = fan->outletNodeNum;
+                furnace.fanAvailSched = fan->availSched;
             }
 
+            furnace.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(8)));
+            furnace.HeatCoilName = Alphas(9);
+
             // Get heating coil type and name data
-            if (Alphas(8) == "COIL:HEATING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION") {
-                HeatingCoilType = Alphas(8);
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingWaterToAirHP;
-                HeatingCoilName = Alphas(9);
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHP) {
+                furnace.HeatCoilNum = WaterToAirHeatPump::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), furnace.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.HeatingCoilIndex = WaterToAirHeatPump::GetCoilIndex(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    HeatingCoilInletNode = WaterToAirHeatPump::GetCoilInletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    HeatingCoilOutletNode = WaterToAirHeatPump::GetCoilOutletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                }
-            } else if (Alphas(8) == "COIL:HEATING:WATERTOAIRHEATPUMP:EQUATIONFIT") {
-                HeatingCoilType = Alphas(8);
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingWaterToAirHPSimple;
-                HeatingCoilName = Alphas(9);
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                    furnace.HeatCoilAirInletNode = WaterToAirHeatPump::GetCoilInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = WaterToAirHeatPump::GetCoilOutletNode(state, furnace.HeatCoilNum);
+                }
+                
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
+                furnace.HeatCoilNum = WaterToAirHeatPumpSimple::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), furnace.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.HeatingCoilIndex = WaterToAirHeatPumpSimple::GetCoilIndex(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    HeatingCoilInletNode = WaterToAirHeatPumpSimple::GetCoilInletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    HeatingCoilOutletNode = WaterToAirHeatPumpSimple::GetCoilOutletNode(state, HeatingCoilType, HeatingCoilName, errFlag);
-                }
-            } else if (Alphas(8) == "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") {
-                HeatingCoilType = Alphas(8);
-                thisFurnace.HeatingCoilType_Num = HVAC::Coil_HeatingWaterToAirHPVSEquationFit;
-                HeatingCoilName = Alphas(9);
-                ValidateComponent(state, HeatingCoilType, HeatingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                    furnace.HeatCoilAirInletNode = WaterToAirHeatPumpSimple::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = WaterToAirHeatPumpSimple::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
+                }
+                
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
+                furnace.HeatCoilNum = VariableSpeedCoils::GetCoilIndex(state, furnace.HeatCoilName);
+                if (furnace.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(9), furnace.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.HeatingCoilIndex = VariableSpeedCoils::GetCoilIndexVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    HeatingCoilInletNode = VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                    HeatingCoilOutletNode = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
+                    furnace.HeatCoilAirInletNode = VariableSpeedCoils::GetCoilAirInletNode(state, furnace.HeatCoilNum);
+                    furnace.HeatCoilAirOutletNode = VariableSpeedCoils::GetCoilAirOutletNode(state, furnace.HeatCoilNum);
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(8), Alphas(8)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(8), Alphas(8));
                 ErrorsFound = true;
             }
 
             // Get Cooling Coil Information if available
-            if (Alphas(10) == "COIL:COOLING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION") {
-                CoolingCoilType = Alphas(10);
-                thisFurnace.CoolingCoilType_Num = HVAC::Coil_CoolingWaterToAirHP;
-                CoolingCoilName = Alphas(11);
-                ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            furnace.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(10)));
+            furnace.CoolCoilName = Alphas(11);
+
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHP) {
+                furnace.CoolCoilNum = WaterToAirHeatPump::GetCoilIndex(state, furnace.CoolCoilName);
+                if (furnace.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.CoolCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.CoolingCoilIndex = WaterToAirHeatPump::GetCoilIndex(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilInletNode = WaterToAirHeatPump::GetCoilInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode = WaterToAirHeatPump::GetCoilOutletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                }
-            } else if (Alphas(10) == "COIL:COOLING:WATERTOAIRHEATPUMP:EQUATIONFIT") {
-                CoolingCoilType = Alphas(10);
-                thisFurnace.CoolingCoilType_Num = HVAC::Coil_CoolingWaterToAirHPSimple;
-                CoolingCoilName = Alphas(11);
-                ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                    furnace.CoolCoilAirInletNode = WaterToAirHeatPump::GetCoilInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = WaterToAirHeatPump::GetCoilOutletNode(state, furnace.CoolCoilNum);
+                }
+                
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHPSimple) { 
+                furnace.CoolCoilNum = WaterToAirHeatPumpSimple::GetCoilIndex(state, furnace.CoolCoilName);
+                if (furnace.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.CoolCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.CoolingCoilIndex = WaterToAirHeatPumpSimple::GetCoilIndex(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilInletNode = WaterToAirHeatPumpSimple::GetCoilInletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode = WaterToAirHeatPumpSimple::GetCoilOutletNode(state, CoolingCoilType, CoolingCoilName, errFlag);
-                }
-            } else if (Alphas(10) == "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") {
-                CoolingCoilType = Alphas(10);
-                thisFurnace.CoolingCoilType_Num = HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
-                CoolingCoilName = Alphas(11);
-                ValidateComponent(state, CoolingCoilType, CoolingCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                    furnace.CoolCoilAirInletNode = WaterToAirHeatPumpSimple::GetCoilAirInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = WaterToAirHeatPumpSimple::GetCoilAirOutletNode(state, furnace.CoolCoilNum);
+                }
+            
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) { 
+                furnace.CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, furnace.CoolCoilName);
+                if (furnace.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), furnace.CoolCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.CoolingCoilIndex = VariableSpeedCoils::GetCoilIndexVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilInletNode = VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
+                    furnace.CoolCoilAirInletNode = VariableSpeedCoils::GetCoilAirInletNode(state, furnace.CoolCoilNum);
+                    furnace.CoolCoilAirOutletNode = VariableSpeedCoils::GetCoilAirOutletNode(state, furnace.CoolCoilNum);
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(10), Alphas(10)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(10), Alphas(10));
                 ErrorsFound = true;
             }
 
-            thisFurnace.WaterCyclingMode = (NumAlphas < 18 || lAlphaBlanks(18))
+            furnace.WaterCyclingMode = (NumAlphas < 18 || lAlphaBlanks(18))
                                                ? HVAC::WaterFlow::Cycling
                                                : static_cast<HVAC::WaterFlow>(getEnumValue(HVAC::waterFlowNamesUC, Alphas(18)));
 
             // end get water flow mode info
-            if (Alphas(8) == "COIL:HEATING:WATERTOAIRHEATPUMP:EQUATIONFIT" && Alphas(10) == "COIL:COOLING:WATERTOAIRHEATPUMP:EQUATIONFIT") {
-                thisFurnace.WatertoAirHPType = WAHPCoilType::Simple;
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPSimple &&
+                furnace.coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
+                furnace.WatertoAirHPType = WAHPCoilType::Simple;
                 WaterToAirHeatPumpSimple::SetSimpleWSHPData(
-                    state, thisFurnace.CoolingCoilIndex, ErrorsFound, thisFurnace.WaterCyclingMode, _, thisFurnace.HeatingCoilIndex);
-            } else if (Alphas(8) == "COIL:HEATING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION" &&
-                       Alphas(10) == "COIL:COOLING:WATERTOAIRHEATPUMP:PARAMETERESTIMATION") {
-                thisFurnace.WatertoAirHPType = WAHPCoilType::ParEst;
-            } else if (Alphas(8) == "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT" &&
-                       Alphas(10) == "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") {
-                thisFurnace.WatertoAirHPType = WAHPCoilType::VarSpeedEquationFit;
-                VariableSpeedCoils::SetVarSpeedCoilData(state, thisFurnace.CoolingCoilIndex, ErrorsFound, _, thisFurnace.HeatingCoilIndex);
+                    state, furnace.CoolCoilNum, ErrorsFound, furnace.WaterCyclingMode, _, furnace.HeatCoilNum);
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHP &&
+                       furnace.coolCoilType == HVAC::CoilType::CoolingWAHP) {
+                furnace.WatertoAirHPType = WAHPCoilType::ParEst;
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit &&
+                       furnace.coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) { 
+                furnace.WatertoAirHPType = WAHPCoilType::VarSpeedEquationFit;
+                VariableSpeedCoils::SetCoilData(state, furnace.CoolCoilNum, _, furnace.HeatCoilNum);
             } else {
-                ShowContinueError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, "Cooling coil and heating coil should be of same general type");
+                ShowSevereCustom(state, eoh, "Cooling coil and heating coil should be of same general type");
                 ErrorsFound = true;
             }
 
             // Get supplemental heating coil information
+            furnace.suppHeatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(12)));
+            furnace.SuppCoilName = Alphas(13);
 
-            SuppHeatCoilType = Alphas(12);
-            SuppHeatCoilName = Alphas(13);
-            thisFurnace.SuppHeatCoilType = SuppHeatCoilType;
-            thisFurnace.SuppHeatCoilName = SuppHeatCoilName;
-            errFlag = false;
-            if (Util::SameString(SuppHeatCoilType, "Coil:Heating:Fuel") || Util::SameString(SuppHeatCoilType, "Coil:Heating:Electric")) {
+            if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                furnace.suppHeatCoilType == HVAC::CoilType::HeatingElectric) {
 
-                thisFurnace.SuppHeatCoilType_Num = HeatingCoils::GetHeatingCoilTypeNum(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                furnace.SuppCoilNum = HeatingCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                if (furnace.SuppCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.SuppCoilName);
                     ErrorsFound = true;
                 } else {
-                    IsNotOK = false;
-                    ValidateComponent(state, SuppHeatCoilType, SuppHeatCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("In {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                        ErrorsFound = true;
-
-                    } else { // mine data from the supplemental heating coil
-
-                        HeatingCoils::GetCoilIndex(state, SuppHeatCoilName, thisFurnace.SuppHeatCoilIndex, IsNotOK);
-                        if (IsNotOK) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Supplemental Heating Coil Inlet Node Number
-                        errFlag = false;
-                        SupHeatCoilInletNode = HeatingCoils::GetCoilInletNode(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} \"{}\"", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the Supplemental Heating Coil Outlet Node Number
-                        errFlag = false;
-                        SupHeatCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                        // Get the supplemental heating coil design capacity
-                        errFlag = false;
-                        thisFurnace.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                            ErrorsFound = true;
-                        }
-
-                    } // IF (IsNotOK) THEN
-                }
-            } else if (Util::SameString(SuppHeatCoilType, "Coil:Heating:Water")) {
-                thisFurnace.SuppHeatCoilType_Num = HVAC::Coil_HeatingWater;
-                ValidateComponent(state, SuppHeatCoilType, SuppHeatCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+                    furnace.SuppCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                    furnace.SuppCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
+                    furnace.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, furnace.SuppCoilNum);
+                }
+                
+            } else if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
+                furnace.SuppCoilNum = WaterCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                if (furnace.SuppCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.SuppCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    // Get the Heating Coil water Inlet or control Node number
-                    errFlag = false;
-                    thisFurnace.SuppCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil hot water max volume flow rate
-                    errFlag = false;
-                    thisFurnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil Inlet Node
-                    errFlag = false;
-                    SupHeatCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirInletNode = SupHeatCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil Outlet Node
-                    errFlag = false;
-                    SupHeatCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirOutletNode = SupHeatCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    errFlag = false;
-                    HVACControllers::CheckCoilWaterInletNode(state, thisFurnace.CoilControlNode, errFlag);
+                } else {
+                    furnace.SuppCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, furnace.SuppCoilNum);
+                    furnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.SuppCoilNum);
+                    furnace.SuppCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                    furnace.SuppCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
+                    HVACControllers::CheckCoilWaterInletNode(state, furnace.SuppCoilControlNode, errFlag);
                     if (!errFlag) { // then did find a controller so that is bad
                         ShowSevereError(state,
-                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, thisFurnace.Name));
+                                        format("{} = {} has a conflicting Controller:WaterCoil object", CurrentModuleObject, furnace.Name));
                         ShowContinueError(state, "Hot water coils are controlled directly by unitary and furnace systems.");
                         ShowContinueError(state, "No water coil controller should be input for the coil.");
                         ErrorsFound = true;
                     }
                 }
 
-            } else if (Util::SameString(SuppHeatCoilType, "Coil:Heating:Steam")) {
-                thisFurnace.SuppHeatCoilType_Num = HVAC::Coil_HeatingSteam;
-                ValidateComponent(state, SuppHeatCoilType, SuppHeatCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
+            } else if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
+                furnace.SuppCoilNum = SteamCoils::GetCoilIndex(state, furnace.SuppCoilName);
+                if (furnace.SuppCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), furnace.SuppCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    errFlag = false;
-                    thisFurnace.SuppHeatCoilIndex = SteamCoils::GetSteamCoilIndex(state, SuppHeatCoilType, SuppHeatCoilName, errFlag);
-                    if (thisFurnace.SuppHeatCoilIndex == 0) {
-                        ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(12), SuppHeatCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil steam inlet node number
-                    errFlag = false;
-                    thisFurnace.SuppCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Heating Coil steam max volume flow rate
-                    thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag);
-                    if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) {
-                        SteamDensity =
-                            Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, getAirLoopHVACHeatCoolInput);
-                        thisFurnace.MaxSuppCoilFluidFlow =
-                            SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, errFlag) * SteamDensity;
-                    }
-
-                    // Get the Heating Coil Inlet Node
-                    errFlag = false;
-                    SupHeatCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisFurnace.SuppHeatCoilIndex, SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirInletNode = SupHeatCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
+                } else {
+                    furnace.SuppCoilControlNode = SteamCoils::GetCoilSteamInletNode(state, furnace.SuppCoilNum);
+                    furnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.SuppCoilNum);
+                    if (furnace.MaxSuppCoilFluidFlow > 0.0) {
+                        furnace.MaxSuppCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, getAirLoopHVACHeatCoolInput);
                     }
 
-                    // Get the Heating Coil Outlet Node
-                    errFlag = false;
-                    SupHeatCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisFurnace.SuppHeatCoilIndex, SuppHeatCoilName, errFlag);
-                    thisFurnace.SuppCoilAirOutletNode = SupHeatCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisFurnace.Name));
-                        ErrorsFound = true;
-                    }
+                    furnace.SuppCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, furnace.SuppCoilNum);
+                    furnace.SuppCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, furnace.SuppCoilNum);
                 }
 
             } else {
-                ShowSevereError(state, format("{} = {}", CurrentModuleObject, Alphas(1)));
-                ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(12), Alphas(12)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(12), Alphas(12));
                 ErrorsFound = true;
             } // IF (Furnace(FurnaceNum)%HeatingCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
 
             if (lAlphaBlanks(14)) {
-                thisFurnace.CondenserNodeNum = 0;
+                furnace.CondenserNodeNum = 0;
             } else {
-                thisFurnace.CondenserNodeNum =
+                furnace.CondenserNodeNum =
                     NodeInputManager::GetOnlySingleNode(state,
                                                         Alphas(14),
                                                         ErrorsFound,
@@ -3978,7 +2970,7 @@ namespace Furnaces {
                                                         NodeInputManager::CompFluidStream::Primary,
                                                         DataLoopNode::ObjectIsNotParent);
                 // need better verification.
-                if (!OutAirNodeManager::CheckOutAirNodeNumber(state, thisFurnace.CondenserNodeNum)) {
+                if (!OutAirNodeManager::CheckOutAirNodeNumber(state, furnace.CondenserNodeNum)) {
                     ShowSevereError(state, format("For {} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(state, format(" Node name of outdoor dry-bulb temperature sensor not valid outdoor air node= {}", Alphas(14)));
                     ShowContinueError(state, "...does not appear in an OutdoorAir:NodeList or as an OutdoorAir:Node.");
@@ -3986,18 +2978,18 @@ namespace Furnaces {
                 }
             }
 
-            thisFurnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(15)));
-            assert(thisFurnace.fanPlace != HVAC::FanPlace::Invalid);
+            furnace.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(15)));
+            assert(furnace.fanPlace != HVAC::FanPlace::Invalid);
 
             if (lAlphaBlanks(16)) {
-                thisFurnace.fanOp = HVAC::FanOp::Cycling;
-                if (thisFurnace.fanType != HVAC::FanType::OnOff) {
-                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, thisFurnace.Name));
+                furnace.fanOp = HVAC::FanOp::Cycling;
+                if (furnace.fanType != HVAC::FanType::OnOff) {
+                    ShowSevereError(state, format("{} = {}", CurrentModuleObject, furnace.Name));
                     ShowContinueError(state, format("{} = {}", cAlphaFields(6), Alphas(6)));
                     ShowContinueError(state, format("Fan type must be Fan:OnOff when {} = Blank.", cAlphaFields(16)));
                     ErrorsFound = true;
                 }
-            } else if ((thisFurnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(16))) == nullptr) {
+            } else if ((furnace.fanOpModeSched = Sched::GetSchedule(state, Alphas(16))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(16), Alphas(16));
                 ErrorsFound = true;
             }
@@ -4006,24 +2998,24 @@ namespace Furnaces {
             if (Util::SameString(Alphas(17), "None") || Util::SameString(Alphas(17), "CoolReheat")) {
                 AirNodeFound = false;
                 if (Util::SameString(Alphas(17), "CoolReheat")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
-                    thisFurnace.Humidistat = true;
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::CoolReheat;
+                    furnace.Humidistat = true;
                     if (lAlphaBlanks(17)) {
                         ShowWarningError(state, format("{} \"{}\"", CurrentModuleObject, Alphas(1)));
                         ShowContinueError(state,
                                           "Dehumidification control type is assumed to be None since a supplemental reheat coil has not been "
                                           "specified and the simulation continues.");
-                        thisFurnace.Humidistat = false;
-                        thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                        furnace.Humidistat = false;
+                        furnace.DehumidControlType_Num = DehumidificationControlMode::None;
                     }
                 }
                 if (Util::SameString(Alphas(17), "None")) {
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
-                    thisFurnace.Humidistat = false;
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                    furnace.Humidistat = false;
                 }
-                if (thisFurnace.Humidistat) {
+                if (furnace.Humidistat) {
                     for (HStatZoneNum = 1; HStatZoneNum <= state.dataZoneCtrls->NumHumidityControlZones; ++HStatZoneNum) {
-                        if (state.dataZoneCtrls->HumidityControlZone(HStatZoneNum).ActualZoneNum != thisFurnace.ControlZoneNum) continue;
+                        if (state.dataZoneCtrls->HumidityControlZone(HStatZoneNum).ActualZoneNum != furnace.ControlZoneNum) continue;
                         AirNodeFound = true;
                     }
                     if (!AirNodeFound) {
@@ -4039,124 +3031,86 @@ namespace Furnaces {
                     ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(17), Alphas(17)));
                     ErrorsFound = true;
                 } else {
-                    thisFurnace.Humidistat = false;
-                    thisFurnace.DehumidControlType_Num = DehumidificationControlMode::None;
+                    furnace.Humidistat = false;
+                    furnace.DehumidControlType_Num = DehumidificationControlMode::None;
                 }
             }
 
             // Add fan to component sets array
-
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
                 CompSetFanInlet = Alphas(3);
                 CompSetCoolInlet = "UNDEFINED";
-                if (FanInletNode != thisFurnace.FurnaceInletNodeNum) {
-                    ShowSevereError(
-                        state, format("For {} = {}, Mismatch between unitary system inlet node and fan inlet node.", CurrentModuleObject, Alphas(1)));
+                if (furnace.FanInletNode != furnace.FurnaceInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between unitary system inlet node and fan inlet node.");
                     ShowContinueError(state, "..For \"BlowThrough\" fan, the inlet node name for the HeatPump should match the fan inlet node name.");
-                    ShowContinueError(state, format("..HeatPump Inlet Node = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
-                    ShowContinueError(state, format("..Fan Inlet Node      = {}", state.dataLoopNodes->NodeID(FanInletNode)));
+                    ShowContinueError(state, format("..HeatPump Inlet Node = {}", s_node->NodeID(furnace.FurnaceInletNode)));
+                    ShowContinueError(state, format("..Fan Inlet Node      = {}", s_node->NodeID(furnace.FanInletNode)));
                     ErrorsFound = true;
                 }
-                if (FanOutletNode != CoolingCoilInletNode) {
-                    ShowSevereError(
-                        state, format("For {} = {}, Mismatch between fan outlet node and cooling coil inlet node.", CurrentModuleObject, Alphas(1)));
+                if (furnace.FanOutletNode != furnace.CoolCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between fan outlet node and cooling coil inlet node.");
                     ShowContinueError(state, "..For \"BlowThrough\" fan, the fan outlet node name must match the cooling coil inlet node name.");
-                    ShowContinueError(state, format("..Fan outlet node         = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                    ShowContinueError(state, format("..Cooling coil inlet node = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
+                    ShowContinueError(state, format("..Fan outlet node         = {}", s_node->NodeID(furnace.FanOutletNode)));
+                    ShowContinueError(state, format("..Cooling coil inlet node = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (CoolingCoilOutletNode != HeatingCoilInletNode) {
-                    ShowSevereError(state,
-                                    format("For {} = {}, Mismatch between cooling coil outlet node and heating coil inlet node.",
-                                           CurrentModuleObject,
-                                           Alphas(1)));
+                if (furnace.CoolCoilAirOutletNode != furnace.HeatCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between cooling coil outlet node and heating coil inlet node.");
                     ShowContinueError(state, "..The cooling coil outlet node name must match the heating coil inlet node name.");
-                    ShowContinueError(state, format("..Cooling coil outlet node = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                    ShowContinueError(state, format("..Heating coil inlet node  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                    ShowContinueError(state, format("..Cooling coil outlet node = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                    ShowContinueError(state, format("..Heating coil inlet node  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (HeatingCoilOutletNode != SupHeatCoilInletNode) {
-                    ShowSevereError(state,
-                                    format("For {} = {}, Mismatch between heating coil outlet node and supplemental heating coil inlet node.",
-                                           CurrentModuleObject,
-                                           Alphas(1)));
-                    ShowContinueError(
-                        state,
-                        "..For \"BlowThrough\" fan, the heating coil outlet node name must match the supplemental heating coil inlet node name.");
-                    ShowContinueError(state,
-                                      format("..Heating coil outlet node             = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                    ShowContinueError(state,
-                                      format("..Supplemental heating coil inlet node = {}", state.dataLoopNodes->NodeID(SupHeatCoilInletNode)));
+                if (furnace.HeatCoilAirOutletNode != furnace.SuppCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between heating coil outlet node and supplemental heating coil inlet node.");
+                    ShowContinueError(state, "..For \"BlowThrough\" fan, the heating coil outlet node name must match the supplemental heating coil inlet node name.");
+                    ShowContinueError(state, format("..Heating coil outlet node             = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("..Supplemental heating coil inlet node = {}", s_node->NodeID(furnace.SuppCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (SupHeatCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                    ShowSevereError(state,
-                                    format("For {} = {}, Mismatch between supplemental heating coil outlet node and HeatPump outlet node.",
-                                           CurrentModuleObject,
-                                           Alphas(1)));
+                if (furnace.SuppCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between supplemental heating coil outlet node and HeatPump outlet node.");
                     ShowContinueError(state, "..The supplemental heating coil outlet node name must match the HeatPump outlet node name.");
-                    ShowContinueError(state,
-                                      format("..Supplemental heating coil outlet node = {}", state.dataLoopNodes->NodeID(SupHeatCoilOutletNode)));
-                    ShowContinueError(
-                        state, format("..HeatPump outlet node                  = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                    ShowContinueError(state, format("..Supplemental heating coil outlet node = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
+                    ShowContinueError(state, format("..HeatPump outlet node                  = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     ErrorsFound = true;
                 }
             } else {
                 CompSetFanInlet = "UNDEFINED";
                 CompSetCoolInlet = Alphas(3);
-                if (CoolingCoilInletNode != thisFurnace.FurnaceInletNodeNum) {
-                    ShowSevereError(state,
-                                    format("For {} = {}, Mismatch between unitary system inlet node and cooling coil inlet node.",
-                                           CurrentModuleObject,
-                                           Alphas(1)));
-                    ShowContinueError(
-                        state, "..For \"DrawThrough\" fan, the inlet node name for the HeatPump should match the cooling coil inlet node name.");
-                    ShowContinueError(state, format("..HeatPump inlet node     = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceInletNodeNum)));
-                    ShowContinueError(state, format("..Cooling coil inlet node = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
+                if (furnace.CoolCoilAirInletNode != furnace.FurnaceInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between unitary system inlet node and cooling coil inlet node.");
+                    ShowContinueError(state, "..For \"DrawThrough\" fan, the inlet node name for the HeatPump should match the cooling coil inlet node name.");
+                    ShowContinueError(state, format("..HeatPump inlet node     = {}", s_node->NodeID(furnace.FurnaceInletNode)));
+                    ShowContinueError(state, format("..Cooling coil inlet node = {}", s_node->NodeID(furnace.CoolCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (CoolingCoilOutletNode != HeatingCoilInletNode) {
-                    ShowSevereError(state,
-                                    format("For {} = {}, Mismatch between cooling coil outlet node and heating coil inlet node.",
-                                           CurrentModuleObject,
-                                           Alphas(1)));
+                if (furnace.CoolCoilAirOutletNode != furnace.HeatCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between cooling coil outlet node and heating coil inlet node.");
                     ShowContinueError(state, "..The outlet node name for the cooling coil should match the heating coil inlet node name.");
-                    ShowContinueError(state, format("..Cooling coil outlet node = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                    ShowContinueError(state, format("..Heating coil inlet node  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                    ShowContinueError(state, format("..Cooling coil outlet node = {}", s_node->NodeID(furnace.CoolCoilAirOutletNode)));
+                    ShowContinueError(state, format("..Heating coil inlet node  = {}", s_node->NodeID(furnace.HeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (HeatingCoilOutletNode != FanInletNode) {
-                    ShowSevereError(
-                        state, format("For {} = {}, Mismatch between heating coil outlet node and fan inlet node.", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      "..For \"DrawThrough\" fan, the outlet node name for the heating coil should match the fan inlet node name.");
-                    ShowContinueError(state, format("..Heating coil outlet node = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                    ShowContinueError(state, format("..Fan inlet node           = {}", state.dataLoopNodes->NodeID(FanInletNode)));
+                if (furnace.HeatCoilAirOutletNode != furnace.FanInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between heating coil outlet node and fan inlet node.");
+                    ShowContinueError(state, "..For \"DrawThrough\" fan, the outlet node name for the heating coil should match the fan inlet node name.");
+                    ShowContinueError(state, format("..Heating coil outlet node = {}", s_node->NodeID(furnace.HeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("..Fan inlet node           = {}", s_node->NodeID(furnace.FanInletNode)));
                     ErrorsFound = true;
                 }
-                if (FanOutletNode != SupHeatCoilInletNode) {
-                    ShowSevereError(state,
-                                    format("For {} = {}, Mismatch between fan outlet node and supplemental heating coil inlet node.",
-                                           CurrentModuleObject,
-                                           Alphas(1)));
-                    ShowContinueError(
-                        state,
-                        "..For \"DrawThrough\" fan, the outlet node name for the fan should match the supplemental heating coil inlet node name.");
-                    ShowContinueError(state, format("..Fan outlet node                      = {}", state.dataLoopNodes->NodeID(FanOutletNode)));
-                    ShowContinueError(state,
-                                      format("..Supplemental heating coil inlet node = {}", state.dataLoopNodes->NodeID(SupHeatCoilInletNode)));
+                if (furnace.FanOutletNode != furnace.SuppCoilAirInletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between fan outlet node and supplemental heating coil inlet node.");
+                    ShowContinueError(state, "For \"DrawThrough\" fan, the outlet node name for the fan should match the supplemental heating coil inlet node name.");
+                    ShowContinueError(state, format("..Fan outlet node                      = {}", s_node->NodeID(furnace.FanOutletNode)));
+                    ShowContinueError(state, format("..Supplemental heating coil inlet node = {}", s_node->NodeID(furnace.SuppCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (SupHeatCoilOutletNode != thisFurnace.FurnaceOutletNodeNum) {
-                    ShowSevereError(state,
-                                    format("For {} = {}, Mismatch between supplemental heating coil outlet node and HeatPump outlet node.",
-                                           CurrentModuleObject,
-                                           Alphas(1)));
-                    ShowContinueError(state, "..The supplemental heating coil outlet node name must match the HeatPump outlet node name.");
-                    ShowContinueError(state,
-                                      format("..Supplemental heating coil outlet node = {}", state.dataLoopNodes->NodeID(SupHeatCoilOutletNode)));
-                    ShowContinueError(
-                        state, format("..HeatPump outlet node                  = {}", state.dataLoopNodes->NodeID(thisFurnace.FurnaceOutletNodeNum)));
+                if (furnace.SuppCoilAirOutletNode != furnace.FurnaceOutletNode) {
+                    ShowSevereCustom(state, eoh, "Mismatch between supplemental heating coil outlet node and HeatPump outlet node."
+                                     "..The supplemental heating coil outlet node name must match the HeatPump outlet node name.");
+                    ShowContinueError(state, format("..Supplemental heating coil outlet node = {}", s_node->NodeID(furnace.SuppCoilAirOutletNode)));
+                    ShowContinueError(state, format("..HeatPump outlet node                  = {}", s_node->NodeID(furnace.FurnaceOutletNode)));
                     ErrorsFound = true;
                 }
             }
@@ -4173,7 +3127,7 @@ namespace Furnaces {
             BranchNodeConnections::SetUpCompSets(state, CurrentModuleObject, Alphas(1), Alphas(12), Alphas(13), "UNDEFINED", Alphas(4));
 
             // Set the Design Fan Volume Flow Rate
-            thisFurnace.ActualFanVolFlowRate = state.dataFans->fans(thisFurnace.FanIndex)->maxAirFlowRate;
+            furnace.ActualFanVolFlowRate = state.dataFans->fans(furnace.FanIndex)->maxAirFlowRate;
 
             // CR8094 - simple water to air heat pump MUST operate at the same flow rate specified in the coil objects
             //        Furnace(FurnaceNum)%DesignFanVolFlowRate = Numbers(1)
@@ -4181,124 +3135,84 @@ namespace Furnaces {
             //        Furnace(FurnaceNum)%MaxCoolAirVolFlow    = Furnace(FurnaceNum)%DesignFanVolFlowRate
 
             // parameter estimate model only specifies air flow rate in parent object
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP) {
-                thisFurnace.MaxHeatAirVolFlow = Numbers(1);
-                thisFurnace.MaxCoolAirVolFlow = Numbers(1);
-                // simple HP model specifies air flow rate in both the parent and child coils. Use coil air flow rates.
-                // simple HP model air flow rate input will not be used.
-            } else if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple) {
-                errFlag = false;
-                thisFurnace.MaxHeatAirVolFlow = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(state, HeatingCoilType, HeatingCoilName, errFlag);
-                thisFurnace.MaxCoolAirVolFlow = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(state, CoolingCoilType, CoolingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            } else if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
-                errFlag = false;
-                thisFurnace.MaxHeatAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                thisFurnace.MaxCoolAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHP) {
+                furnace.MaxHeatAirVolFlow = Numbers(1);
+                furnace.MaxCoolAirVolFlow = Numbers(1);
+
+            // simple HP model specifies air flow rate in both the parent and child coils. Use coil air flow rates.
+            // simple HP model air flow rate input will not be used.
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
+                furnace.MaxHeatAirVolFlow = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(state, furnace.HeatCoilNum);
+                furnace.MaxCoolAirVolFlow = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(state, furnace.CoolCoilNum);
+
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
+                furnace.MaxHeatAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRate(state, furnace.HeatCoilNum);
+                furnace.MaxCoolAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRate(state, furnace.CoolCoilNum);
             }
 
-            thisFurnace.MaxNoCoolHeatAirVolFlow = min(thisFurnace.MaxHeatAirVolFlow, thisFurnace.MaxCoolAirVolFlow);
-            if (thisFurnace.MaxHeatAirVolFlow != DataSizing::AutoSize && thisFurnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
-                thisFurnace.DesignFanVolFlowRate = max(thisFurnace.MaxHeatAirVolFlow, thisFurnace.MaxCoolAirVolFlow);
+            furnace.MaxNoCoolHeatAirVolFlow = min(furnace.MaxHeatAirVolFlow, furnace.MaxCoolAirVolFlow);
+            if (furnace.MaxHeatAirVolFlow != DataSizing::AutoSize && furnace.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+                furnace.DesignFanVolFlowRate = max(furnace.MaxHeatAirVolFlow, furnace.MaxCoolAirVolFlow);
             } else {
-                thisFurnace.DesignFanVolFlowRate = DataSizing::AutoSize;
+                furnace.DesignFanVolFlowRate = DataSizing::AutoSize;
             }
 
-            thisFurnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
+            furnace.AirFlowControl = AirFlowControlConstFan::UseCompressorOnFlow;
 
-            if (thisFurnace.ActualFanVolFlowRate != DataSizing::AutoSize && thisFurnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.DesignFanVolFlowRate > thisFurnace.ActualFanVolFlowRate) {
+            if (furnace.ActualFanVolFlowRate != DataSizing::AutoSize && furnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.DesignFanVolFlowRate > furnace.ActualFanVolFlowRate) {
                     ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(state, "... has a Cooling or Heating Air Flow Rate > Max Fan Volume Flow Rate, should be <=.");
                     ShowContinueError(state,
                                       format("... Entered value={:.2R}... Fan [{}:{}] Max Value={:.2R}",
-                                             thisFurnace.DesignFanVolFlowRate,
-                                             HVAC::fanTypeNames[(int)thisFurnace.fanType],
+                                             furnace.DesignFanVolFlowRate,
+                                             HVAC::fanTypeNames[(int)furnace.fanType],
                                              FanName,
-                                             thisFurnace.ActualFanVolFlowRate));
+                                             furnace.ActualFanVolFlowRate));
                 }
             }
-            if (thisFurnace.ActualFanVolFlowRate != DataSizing::AutoSize && thisFurnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.DesignFanVolFlowRate <= 0.0) {
+            if (furnace.ActualFanVolFlowRate != DataSizing::AutoSize && furnace.DesignFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.DesignFanVolFlowRate <= 0.0) {
                     ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
                     ShowContinueError(state, "... has a Design Fan Flow Rate <= 0.0, it must be >0.0");
-                    ShowContinueError(state, format("... Entered value={:.2R}", thisFurnace.DesignFanVolFlowRate));
+                    ShowContinueError(state, format("... Entered value={:.2R}", furnace.DesignFanVolFlowRate));
                     ErrorsFound = true;
                 }
             }
 
             // Set the heat pump heating coil capacity
             //  Get from coil module.
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP) {
-                errFlag = false;
-                thisFurnace.DesignHeatingCapacity = WaterToAirHeatPump::GetCoilCapacity(state, HeatingCoilType, HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            } else if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple) {
-                errFlag = false;
-                thisFurnace.DesignHeatingCapacity = WaterToAirHeatPumpSimple::GetCoilCapacity(state, HeatingCoilType, HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            } else if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
-                errFlag = false;
-                thisFurnace.DesignHeatingCapacity =
-                    VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, HeatingCoilType, HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHP) {
+                furnace.DesignHeatingCapacity = WaterToAirHeatPump::GetCoilCapacity(state, furnace.HeatCoilNum);
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
+                furnace.DesignHeatingCapacity = WaterToAirHeatPumpSimple::GetCoilCapacity(state, furnace.HeatCoilNum);
+            } else if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
+                furnace.DesignHeatingCapacity = VariableSpeedCoils::GetCoilCapacity(state, furnace.HeatCoilNum);
             }
             // Set the heat pump heating coil convergence
-            thisFurnace.HeatingConvergenceTolerance = Numbers(2);
+            furnace.HeatingConvergenceTolerance = Numbers(2);
             // Set the heat pump cooling coil capacity (Total capacity)
             //  Get from coil module.
-            if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHP) {
-                errFlag = false;
-                thisFurnace.DesignCoolingCapacity = WaterToAirHeatPump::GetCoilCapacity(state, CoolingCoilType, CoolingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
-                errFlag = false;
-                thisFurnace.DesignCoolingCapacity = WaterToAirHeatPumpSimple::GetCoilCapacity(state, CoolingCoilType, CoolingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
-            } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
-                errFlag = false;
-                thisFurnace.DesignCoolingCapacity =
-                    VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, CoolingCoilType, CoolingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("...occurs in {} = {}", CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                }
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHP) {
+                furnace.DesignCoolingCapacity = WaterToAirHeatPump::GetCoilCapacity(state, furnace.CoolCoilNum);
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
+                furnace.DesignCoolingCapacity = WaterToAirHeatPumpSimple::GetCoilCapacity(state, furnace.CoolCoilNum);
+            } else if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
+                furnace.DesignCoolingCapacity = VariableSpeedCoils::GetCoilCapacity(state, furnace.CoolCoilNum);
             }
             // Set the heat pump cooling coil convergence
-            thisFurnace.CoolingConvergenceTolerance = Numbers(3);
+            furnace.CoolingConvergenceTolerance = Numbers(3);
 
             // Set the heatpump design supplemental heating capacity
             //  Get from coil module.
 
             // Set the heatpump max outlet temperature
-            thisFurnace.DesignMaxOutletTemp = Numbers(4);
+            furnace.DesignMaxOutletTemp = Numbers(4);
 
             // Set maximum supply air temperature for supplemental heating coil
-            thisFurnace.MaxOATSuppHeat = Numbers(5);
+            furnace.MaxOATSuppHeat = Numbers(5);
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, HeatingCoilName, thisFurnace.MaxOATSuppHeat);
+                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, furnace.HeatCoilName, furnace.MaxOATSuppHeat);
 
             // set minimum outdoor temperature for compressor operation
             SetMinOATCompressor(state, FurnaceNum, cCurrentModuleObject, ErrorsFound);
@@ -4314,96 +3228,96 @@ namespace Furnaces {
 
         for (int HeatOnlyNum = 1; HeatOnlyNum <= NumHeatOnly; ++HeatOnlyNum) {
             FurnaceNum = HeatOnlyNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
             // Setup Report variables for the Furnace that are not reported in the components themselves
             SetupOutputVariable(state,
                                 "Unitary System Fan Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.FanPartLoadRatio,
+                                furnace.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:Unitary:Furnace:HeatOnly",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate",
                                  "[m3/s]",
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideOn,
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideValue);
+                                 furnace.DesignFanVolFlowRateEMSOverrideOn,
+                                 furnace.DesignFanVolFlowRateEMSOverrideValue);
             }
         }
 
         for (int UnitaryHeatOnlyNum = NumHeatOnly + 1; UnitaryHeatOnlyNum <= NumHeatOnly + NumUnitaryHeatOnly; ++UnitaryHeatOnlyNum) {
             FurnaceNum = UnitaryHeatOnlyNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
             // Setup Report variables for Unitary System that are not reported in the components themselves
             SetupOutputVariable(state,
                                 "Unitary System Fan Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.FanPartLoadRatio,
+                                furnace.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:UnitaryHeatOnly",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate",
                                  "[m3/s]",
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideOn,
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideValue);
+                                 furnace.DesignFanVolFlowRateEMSOverrideOn,
+                                 furnace.DesignFanVolFlowRateEMSOverrideValue);
             }
         }
 
         for (int HeatCoolNum = NumHeatOnly + NumUnitaryHeatOnly + 1; HeatCoolNum <= NumHeatOnly + NumUnitaryHeatOnly + NumHeatCool; ++HeatCoolNum) {
             FurnaceNum = HeatCoolNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
             // Setup Report variables for the Furnace that are not reported in the components themselves
             SetupOutputVariable(state,
                                 "Unitary System Fan Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.FanPartLoadRatio,
+                                furnace.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Compressor Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.CompPartLoadRatio,
+                                furnace.CompPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
 
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:Unitary:Furnace:HeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate",
                                  "[m3/s]",
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideOn,
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideValue);
+                                 furnace.DesignFanVolFlowRateEMSOverrideOn,
+                                 furnace.DesignFanVolFlowRateEMSOverrideValue);
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:Unitary:Furnace:HeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate During Cooling Operation",
                                  "[m3/s]",
-                                 thisFurnace.MaxCoolAirVolFlowEMSOverrideOn,
-                                 thisFurnace.MaxCoolAirVolFlowEMSOverrideValue);
+                                 furnace.MaxCoolAirVolFlowEMSOverrideOn,
+                                 furnace.MaxCoolAirVolFlowEMSOverrideValue);
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:Unitary:Furnace:HeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate During Heating Operation",
                                  "[m3/s]",
-                                 thisFurnace.MaxHeatAirVolFlowEMSOverrideOn,
-                                 thisFurnace.MaxHeatAirVolFlowEMSOverrideValue);
+                                 furnace.MaxHeatAirVolFlowEMSOverrideOn,
+                                 furnace.MaxHeatAirVolFlowEMSOverrideValue);
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:Unitary:Furnace:HeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate During No Heating or Cooling Operation",
                                  "[m3/s]",
-                                 thisFurnace.MaxNoCoolHeatAirVolFlowEMSOverrideOn,
-                                 thisFurnace.MaxNoCoolHeatAirVolFlowEMSOverrideValue);
+                                 furnace.MaxNoCoolHeatAirVolFlowEMSOverrideOn,
+                                 furnace.MaxNoCoolHeatAirVolFlowEMSOverrideValue);
             }
         }
 
@@ -4411,51 +3325,51 @@ namespace Furnaces {
              UnitaryHeatCoolNum <= NumHeatOnly + NumHeatCool + NumUnitaryHeatOnly + NumUnitaryHeatCool;
              ++UnitaryHeatCoolNum) {
             FurnaceNum = UnitaryHeatCoolNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
             // Setup Report variables for Unitary System that are not reported in the components themselves
             SetupOutputVariable(state,
                                 "Unitary System Fan Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.FanPartLoadRatio,
+                                furnace.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Compressor Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.CompPartLoadRatio,
+                                furnace.CompPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:UnitaryHeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate",
                                  "[m3/s]",
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideOn,
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideValue);
+                                 furnace.DesignFanVolFlowRateEMSOverrideOn,
+                                 furnace.DesignFanVolFlowRateEMSOverrideValue);
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:UnitaryHeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate During Cooling Operation",
                                  "[m3/s]",
-                                 thisFurnace.MaxCoolAirVolFlowEMSOverrideOn,
-                                 thisFurnace.MaxCoolAirVolFlowEMSOverrideValue);
+                                 furnace.MaxCoolAirVolFlowEMSOverrideOn,
+                                 furnace.MaxCoolAirVolFlowEMSOverrideValue);
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:UnitaryHeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate During Heating Operation",
                                  "[m3/s]",
-                                 thisFurnace.MaxHeatAirVolFlowEMSOverrideOn,
-                                 thisFurnace.MaxHeatAirVolFlowEMSOverrideValue);
+                                 furnace.MaxHeatAirVolFlowEMSOverrideOn,
+                                 furnace.MaxHeatAirVolFlowEMSOverrideValue);
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:UnitaryHeatCool",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate During No Heating or Cooling Operation",
                                  "[m3/s]",
-                                 thisFurnace.MaxNoCoolHeatAirVolFlowEMSOverrideOn,
-                                 thisFurnace.MaxNoCoolHeatAirVolFlowEMSOverrideValue);
+                                 furnace.MaxNoCoolHeatAirVolFlowEMSOverrideOn,
+                                 furnace.MaxNoCoolHeatAirVolFlowEMSOverrideValue);
             }
         }
 
@@ -4463,38 +3377,38 @@ namespace Furnaces {
              HeatPumpNum <= state.dataFurnaces->NumFurnaces - NumWaterToAirHeatPump;
              ++HeatPumpNum) {
             FurnaceNum = HeatPumpNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
             // Setup Report variables for Unitary System that are not reported in the components themselves
             SetupOutputVariable(state,
                                 "Unitary System Fan Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.FanPartLoadRatio,
+                                furnace.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Compressor Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.CompPartLoadRatio,
+                                furnace.CompPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Dehumidification Induced Heating Demand Rate",
                                 Constant::Units::W,
-                                thisFurnace.DehumidInducedHeatingDemandRate,
+                                furnace.DehumidInducedHeatingDemandRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
 
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:UnitaryHeatPump:AirToAir",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate",
                                  "[m3/s]",
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideOn,
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideValue);
+                                 furnace.DesignFanVolFlowRateEMSOverrideOn,
+                                 furnace.DesignFanVolFlowRateEMSOverrideValue);
             }
         }
 
@@ -4502,81 +3416,81 @@ namespace Furnaces {
              HeatPumpNum <= state.dataFurnaces->NumFurnaces;
              ++HeatPumpNum) {
             FurnaceNum = HeatPumpNum;
-            auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+            auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
             // Setup Report variables for Unitary System that are not reported in the components themselves
             SetupOutputVariable(state,
                                 "Unitary System Fan Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.FanPartLoadRatio,
+                                furnace.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Compressor Part Load Ratio",
                                 Constant::Units::None,
-                                thisFurnace.CompPartLoadRatio,
+                                furnace.CompPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Requested Sensible Cooling Rate",
                                 Constant::Units::W,
-                                thisFurnace.CoolingCoilSensDemand,
+                                furnace.CoolingCoilSensDemand,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Requested Latent Cooling Rate",
                                 Constant::Units::W,
-                                thisFurnace.CoolingCoilLatentDemand,
+                                furnace.CoolingCoilLatentDemand,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Requested Heating Rate",
                                 Constant::Units::W,
-                                thisFurnace.HeatingCoilSensDemand,
+                                furnace.HeatingCoilSensDemand,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
             SetupOutputVariable(state,
                                 "Unitary System Dehumidification Induced Heating Demand Rate",
                                 Constant::Units::W,
-                                thisFurnace.DehumidInducedHeatingDemandRate,
+                                furnace.DehumidInducedHeatingDemandRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisFurnace.Name);
+                                furnace.Name);
 
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
                                  "AirLoopHVAC:UnitaryHeatPump:WaterToAir",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Autosized Supply Air Flow Rate",
                                  "[m3/s]",
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideOn,
-                                 thisFurnace.DesignFanVolFlowRateEMSOverrideValue);
+                                 furnace.DesignFanVolFlowRateEMSOverrideOn,
+                                 furnace.DesignFanVolFlowRateEMSOverrideValue);
             }
         }
 
         if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
             for (FurnaceNum = 1; FurnaceNum <= state.dataFurnaces->NumFurnaces; ++FurnaceNum) {
-                auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-                SetupEMSInternalVariable(state, "Unitary HVAC Design Heating Capacity", thisFurnace.Name, "[W]", thisFurnace.DesignHeatingCapacity);
-                SetupEMSInternalVariable(state, "Unitary HVAC Design Cooling Capacity", thisFurnace.Name, "[W]", thisFurnace.DesignCoolingCapacity);
+                auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+                SetupEMSInternalVariable(state, "Unitary HVAC Design Heating Capacity", furnace.Name, "[W]", furnace.DesignHeatingCapacity);
+                SetupEMSInternalVariable(state, "Unitary HVAC Design Cooling Capacity", furnace.Name, "[W]", furnace.DesignCoolingCapacity);
                 SetupEMSActuator(state,
                                  "Unitary HVAC",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Sensible Load Request",
                                  "[W]",
-                                 thisFurnace.EMSOverrideSensZoneLoadRequest,
-                                 thisFurnace.EMSSensibleZoneLoadValue);
+                                 furnace.EMSOverrideSensZoneLoadRequest,
+                                 furnace.EMSSensibleZoneLoadValue);
                 SetupEMSActuator(state,
                                  "Unitary HVAC",
-                                 thisFurnace.Name,
+                                 furnace.Name,
                                  "Moisture Load Request",
                                  "[W]",
-                                 thisFurnace.EMSOverrideMoistZoneLoadRequest,
-                                 thisFurnace.EMSMoistureZoneLoadValue);
+                                 furnace.EMSOverrideMoistZoneLoadRequest,
+                                 furnace.EMSMoistureZoneLoadValue);
             }
         }
         bool anyRan;
@@ -4643,7 +3557,6 @@ namespace Furnaces {
         bool ErrorsFound(false);                 // flag returned from mining call
         Real64 mdot(0.0);                        // local temporary for mass flow rate (kg/s)
         Real64 rho(0.0);                         // local for fluid density
-        Real64 SteamDensity(0.0);                // density of steam at 100C, used for steam heating coils
         Real64 CoilMaxVolFlowRate(0.0);          // coil fluid maximum volume flow rate
         Real64 QActual(0.0);                     // coil actual capacity
         Real64 SUPHEATERLOAD(0.0);               // SUPPLEMENTAL HEATER LOAD
@@ -4653,9 +3566,9 @@ namespace Furnaces {
         Furnaces::ModeOfOperation OperatingModeMinusTwo;
         bool Oscillate; // detection of oscillating operating modes
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-        int InNode = thisFurnace.FurnaceInletNodeNum;
-        int OutNode = thisFurnace.FurnaceOutletNodeNum;
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+        int InNode = furnace.FurnaceInletNode;
+        int OutNode = furnace.FurnaceOutletNode;
 
         if (state.dataFurnaces->InitFurnaceMyOneTimeFlag) {
             // initialize the environment and sizing flags
@@ -4692,47 +3605,47 @@ namespace Furnaces {
         if (!state.dataGlobal->SysSizingCalc && state.dataFurnaces->MySizeFlag(FurnaceNum)) {
             // for each furnace, do the sizing once.
             SizeFurnace(state, FurnaceNum, FirstHVACIteration);
-            thisFurnace.ControlZoneMassFlowFrac = 1.0;
+            furnace.ControlZoneMassFlowFrac = 1.0;
 
             state.dataFurnaces->MySizeFlag(FurnaceNum) = false;
             // Pass the fan cycling schedule index up to the air loop. Set the air loop unitary system flag.
-            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).cycFanSched = thisFurnace.fanOpModeSched;
+            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).cycFanSched = furnace.fanOpModeSched;
             state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySys = true;
             // RR this is wrong, Op mode needs to be updated each time atep
-            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = thisFurnace.fanOp;
+            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = furnace.fanOp;
 
             // Check that heat pump heating capacity is within 20% of cooling capacity
-            if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
-                if (std::abs(thisFurnace.DesignCoolingCapacity - thisFurnace.DesignHeatingCapacity) / thisFurnace.DesignCoolingCapacity > 0.2) {
+            if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
+                if (std::abs(furnace.DesignCoolingCapacity - furnace.DesignHeatingCapacity) / furnace.DesignCoolingCapacity > 0.2) {
                     ShowWarningError(state,
                                      format("{} \"{}\" heating capacity is disproportionate (> 20% different) to total cooling capacity",
-                                            HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                            thisFurnace.Name));
+                                            HVAC::unitarySysTypeNames[(int)furnace.type],
+                                            furnace.Name));
                 }
             }
         }
 
         if (!state.dataGlobal->DoingSizing && state.dataFurnaces->MySecondOneTimeFlag(FurnaceNum)) {
             // sizing all done.  check fan air flow rates
-            thisFurnace.ActualFanVolFlowRate = state.dataFans->fans(thisFurnace.FanIndex)->maxAirFlowRate;
-            if (thisFurnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.DesignFanVolFlowRate > thisFurnace.ActualFanVolFlowRate) {
+            furnace.ActualFanVolFlowRate = state.dataFans->fans(furnace.FanIndex)->maxAirFlowRate;
+            if (furnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.DesignFanVolFlowRate > furnace.ActualFanVolFlowRate) {
                     ShowWarningError(state,
                                      format("{}={} has a Design Fan Volume Flow Rate > Max Fan Volume Flow Rate, should be <=",
-                                            HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                            thisFurnace.Name));
+                                            HVAC::unitarySysTypeNames[(int)furnace.type],
+                                            furnace.Name));
                     ShowContinueError(state,
                                       format("... Entered value={:.2R}... Fan [{}] Max Value={:.2R}",
-                                             thisFurnace.DesignFanVolFlowRate,
-                                             HVAC::fanTypeNames[(int)thisFurnace.fanType],
-                                             thisFurnace.ActualFanVolFlowRate));
+                                             furnace.DesignFanVolFlowRate,
+                                             HVAC::fanTypeNames[(int)furnace.fanType],
+                                             furnace.ActualFanVolFlowRate));
                 }
-                if (thisFurnace.DesignFanVolFlowRate <= 0.0) {
+                if (furnace.DesignFanVolFlowRate <= 0.0) {
                     ShowSevereError(state,
                                     format("{}={} has a Design Fan Volume Flow Rate <= 0.0, it must be >0.0",
-                                           HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                           thisFurnace.Name));
-                    ShowContinueError(state, format("... Entered value={:.2R}", thisFurnace.DesignFanVolFlowRate));
+                                           HVAC::unitarySysTypeNames[(int)furnace.type],
+                                           furnace.Name));
+                    ShowContinueError(state, format("... Entered value={:.2R}", furnace.DesignFanVolFlowRate));
                 }
 
                 state.dataFurnaces->MySecondOneTimeFlag(FurnaceNum) = false;
@@ -4741,15 +3654,16 @@ namespace Furnaces {
 
         // Scan hot water and steam heating coil plant components for one time initializations
         if (state.dataFurnaces->MyPlantScanFlag(FurnaceNum) && allocated(state.dataPlnt->PlantLoop)) {
-            if ((thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWater) || (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingSteam)) {
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWater ||
+                furnace.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
-                if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
+                if (furnace.heatCoilType == HVAC::CoilType::HeatingWater) {
 
                     errFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(state,
-                                                            thisFurnace.HeatingCoilName,
+                                                            furnace.HeatCoilName,
                                                             DataPlant::PlantEquipmentType::CoilWaterSimpleHeating,
-                                                            thisFurnace.plantLoc,
+                                                            furnace.plantLoc,
                                                             errFlag,
                                                             _,
                                                             _,
@@ -4759,20 +3673,18 @@ namespace Furnaces {
                     if (errFlag) {
                         ShowFatalError(state, "InitFurnace: Program terminated for previous conditions.");
                     }
-                    thisFurnace.MaxHeatCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.HeatingCoilName, ErrorsFound);
-                    if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) {
-                        rho =
-                            state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                        thisFurnace.MaxHeatCoilFluidFlow *= rho;
+                    furnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.HeatCoilNum);
+                    if (furnace.MaxHeatCoilFluidFlow > 0.0) {
+                        Real64 rho = state.dataPlnt->PlantLoop(furnace.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
+                        furnace.MaxHeatCoilFluidFlow *= rho;
                     }
-                } else if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
+                } else if (furnace.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
                     errFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(state,
-                                                            thisFurnace.HeatingCoilName,
+                                                            furnace.HeatCoilName,
                                                             DataPlant::PlantEquipmentType::CoilSteamAirHeating,
-                                                            thisFurnace.plantLoc,
+                                                            furnace.plantLoc,
                                                             errFlag,
                                                             _,
                                                             _,
@@ -4782,14 +3694,13 @@ namespace Furnaces {
                     if (errFlag) {
                         ShowFatalError(state, "InitFurnace: Program terminated for previous conditions.");
                     }
-                    thisFurnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, ErrorsFound);
-                    if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) {
-                        SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, RoutineName);
-                        thisFurnace.MaxHeatCoilFluidFlow *= SteamDensity;
+                    furnace.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.HeatCoilNum);
+                    if (furnace.MaxHeatCoilFluidFlow > 0.0) {
+                        furnace.MaxHeatCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                     }
                 }
                 // fill outlet node for coil
-                thisFurnace.CoilOutletNode = DataPlant::CompData::getPlantComponent(state, thisFurnace.plantLoc).NodeNumOut;
+                furnace.CoilOutletNode = DataPlant::CompData::getPlantComponent(state, furnace.plantLoc).NodeNumOut;
                 state.dataFurnaces->MyPlantScanFlag(FurnaceNum) = false;
             } else { // pthp not connected to plant
                 state.dataFurnaces->MyPlantScanFlag(FurnaceNum) = false;
@@ -4800,14 +3711,15 @@ namespace Furnaces {
 
         // Scan Supplemental hot water and steam heating coil plant components for one time initializations
         if (state.dataFurnaces->MySuppCoilPlantScanFlag(FurnaceNum) && allocated(state.dataPlnt->PlantLoop)) {
-            if ((thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) || (thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam)) {
+            if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingWater ||
+                furnace.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
 
-                if (thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+                if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
                     errFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(state,
-                                                            thisFurnace.SuppHeatCoilName,
+                                                            furnace.SuppCoilName,
                                                             DataPlant::PlantEquipmentType::CoilWaterSimpleHeating,
-                                                            thisFurnace.SuppPlantLoc,
+                                                            furnace.SuppPlantLoc,
                                                             errFlag,
                                                             _,
                                                             _,
@@ -4817,19 +3729,18 @@ namespace Furnaces {
                     if (errFlag) {
                         ShowFatalError(state, "InitFurnace: Program terminated for previous conditions.");
                     }
-                    thisFurnace.MaxSuppCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.SuppHeatCoilName, ErrorsFound);
-                    if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) {
-                        rho = state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum)
+                    furnace.MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.SuppCoilNum);
+                    if (furnace.MaxSuppCoilFluidFlow > 0.0) {
+                        Real64 rho = state.dataPlnt->PlantLoop(furnace.SuppPlantLoc.loopNum)
                                   .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                        thisFurnace.MaxSuppCoilFluidFlow *= rho;
+                        furnace.MaxSuppCoilFluidFlow *= rho;
                     }
-                } else if (thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+                } else if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                     errFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(state,
-                                                            thisFurnace.SuppHeatCoilName,
+                                                            furnace.SuppCoilName,
                                                             DataPlant::PlantEquipmentType::CoilSteamAirHeating,
-                                                            thisFurnace.SuppPlantLoc,
+                                                            furnace.SuppPlantLoc,
                                                             errFlag,
                                                             _,
                                                             _,
@@ -4839,14 +3750,13 @@ namespace Furnaces {
                     if (errFlag) {
                         ShowFatalError(state, "InitFurnace: Program terminated for previous conditions.");
                     }
-                    thisFurnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, ErrorsFound);
-                    if (thisFurnace.MaxSuppCoilFluidFlow > 0.0) {
-                        SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, RoutineName);
-                        thisFurnace.MaxSuppCoilFluidFlow *= SteamDensity;
+                    furnace.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.SuppCoilNum);
+                    if (furnace.MaxSuppCoilFluidFlow > 0.0) {
+                        furnace.MaxSuppCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                     }
                 }
                 // fill outlet node for coil
-                thisFurnace.SuppCoilOutletNode = DataPlant::CompData::getPlantComponent(state, thisFurnace.SuppPlantLoc).NodeNumOut;
+                furnace.SuppCoilOutletNode = DataPlant::CompData::getPlantComponent(state, furnace.SuppPlantLoc).NodeNumOut;
                 state.dataFurnaces->MySuppCoilPlantScanFlag(FurnaceNum) = false;
             } else { // pthp not connected to plant
                 state.dataFurnaces->MySuppCoilPlantScanFlag(FurnaceNum) = false;
@@ -4859,83 +3769,78 @@ namespace Furnaces {
         // Do the Begin Environment initializations
         if (state.dataGlobal->BeginEnvrnFlag && state.dataFurnaces->MyEnvrnFlag(FurnaceNum)) {
             // Change the Volume Flow Rates to Mass Flow Rates
-            thisFurnace.DesignMassFlowRate = thisFurnace.DesignFanVolFlowRate * state.dataEnvrn->StdRhoAir;
-            thisFurnace.MaxCoolAirMassFlow = thisFurnace.MaxCoolAirVolFlow * state.dataEnvrn->StdRhoAir;
-            thisFurnace.MaxHeatAirMassFlow = thisFurnace.MaxHeatAirVolFlow * state.dataEnvrn->StdRhoAir;
-            thisFurnace.MaxNoCoolHeatAirMassFlow = thisFurnace.MaxNoCoolHeatAirVolFlow * state.dataEnvrn->StdRhoAir;
-            thisFurnace.CompPartLoadRatio = 0.0;
-            thisFurnace.CoolingCoilSensDemand = 0.0;
-            thisFurnace.CoolingCoilLatentDemand = 0.0;
-            thisFurnace.HeatingCoilSensDemand = 0.0;
+            furnace.DesignMassFlowRate = furnace.DesignFanVolFlowRate * state.dataEnvrn->StdRhoAir;
+            furnace.MaxCoolAirMassFlow = furnace.MaxCoolAirVolFlow * state.dataEnvrn->StdRhoAir;
+            furnace.MaxHeatAirMassFlow = furnace.MaxHeatAirVolFlow * state.dataEnvrn->StdRhoAir;
+            furnace.MaxNoCoolHeatAirMassFlow = furnace.MaxNoCoolHeatAirVolFlow * state.dataEnvrn->StdRhoAir;
+            furnace.CompPartLoadRatio = 0.0;
+            furnace.CoolingCoilSensDemand = 0.0;
+            furnace.CoolingCoilLatentDemand = 0.0;
+            furnace.HeatingCoilSensDemand = 0.0;
 
-            thisFurnace.SenLoadLoss = 0.0;
-            if (thisFurnace.Humidistat) {
-                thisFurnace.LatLoadLoss = 0.0;
+            furnace.SenLoadLoss = 0.0;
+            if (furnace.Humidistat) {
+                furnace.LatLoadLoss = 0.0;
             }
 
             //   set fluid-side hardware limits
-            if (thisFurnace.CoilControlNode > 0) {
+            if (furnace.HeatCoilControlNode > 0) {
 
-                if (thisFurnace.MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
+                if (furnace.MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
                     // If water coil max water flow rate is autosized, simulate once in order to mine max flow rate
-                    if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
-                        WaterCoils::SimulateWaterCoilComponents(state, thisFurnace.HeatingCoilName, FirstHVACIteration, thisFurnace.HeatingCoilIndex);
-                        CoilMaxVolFlowRate =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.HeatingCoilName, ErrorsFound);
+                    if (furnace.heatCoilType == HVAC::CoilType::HeatingWater) {
+                        WaterCoils::SimulateWaterCoilComponents(state, furnace.HeatCoilName, FirstHVACIteration, furnace.HeatCoilNum);
+                        CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            rho = state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum)
-                                      .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                            thisFurnace.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * rho;
+                            furnace.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate *
+                              state.dataPlnt->PlantLoop(furnace.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
                         }
                     }
                     // If steam coil max steam flow rate is autosized, simulate once in order to mine max flow rate
-                    if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
+                    if (furnace.heatCoilType == HVAC::CoilType::HeatingSteam) {
                         SteamCoils::SimulateSteamCoilComponents(state,
-                                                                thisFurnace.HeatingCoilName,
+                                                                furnace.HeatCoilName,
                                                                 FirstHVACIteration,
-                                                                thisFurnace.HeatingCoilIndex,
+                                                                furnace.HeatCoilNum,
                                                                 1.0,
                                                                 QActual); // QCoilReq, simulate any load > 0 to get max capacity
-                        CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.HeatingCoilIndex, ErrorsFound);
+                        CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, RoutineName);
-                            thisFurnace.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;
+                            furnace.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                         }
                     }
                 }
 
                 PlantUtilities::InitComponentNodes(
-                    state, 0.0, thisFurnace.MaxHeatCoilFluidFlow, thisFurnace.CoilControlNode, thisFurnace.CoilOutletNode);
+                    state, 0.0, furnace.MaxHeatCoilFluidFlow, furnace.HeatCoilControlNode, furnace.CoilOutletNode);
             }
-            if (thisFurnace.SuppCoilControlNode > 0) {
-                if (thisFurnace.MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
-                    if (thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (furnace.SuppCoilControlNode > 0) {
+                if (furnace.MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
+                    if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
                         // If water coil max water flow rate is autosized, simulate once in order to mine max flow rate
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, thisFurnace.SuppHeatCoilName, FirstHVACIteration, thisFurnace.SuppHeatCoilIndex);
-                        CoilMaxVolFlowRate =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.SuppHeatCoilName, ErrorsFound);
+                            state, furnace.SuppCoilName, FirstHVACIteration, furnace.SuppCoilNum);
+                        CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, furnace.SuppCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            rho = state.dataPlnt->PlantLoop(thisFurnace.SuppPlantLoc.loopNum)
+                            rho = state.dataPlnt->PlantLoop(furnace.SuppPlantLoc.loopNum)
                                       .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                            thisFurnace.MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho;
+                            furnace.MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho;
                         }
                     }
-                    if (thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+                    if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                         SteamCoils::SimulateSteamCoilComponents(state,
-                                                                thisFurnace.SuppHeatCoilName,
+                                                                furnace.SuppCoilName,
                                                                 FirstHVACIteration,
-                                                                thisFurnace.SuppHeatCoilIndex,
+                                                                furnace.SuppCoilNum,
                                                                 1.0,
                                                                 QActual); // QCoilReq, simulate any load > 0 to get max capacity
-                        CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, thisFurnace.SuppHeatCoilIndex, ErrorsFound);
+                        CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, furnace.SuppCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataFurnaces->TempSteamIn, 1.0, RoutineName);
-                            thisFurnace.MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;
+                            furnace.MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                         }
                     }
                     PlantUtilities::InitComponentNodes(
-                        state, 0.0, thisFurnace.MaxSuppCoilFluidFlow, thisFurnace.SuppCoilControlNode, thisFurnace.SuppCoilOutletNode);
+                        state, 0.0, furnace.MaxSuppCoilFluidFlow, furnace.SuppCoilControlNode, furnace.SuppCoilOutletNode);
                 }
             }
             state.dataFurnaces->MyEnvrnFlag(FurnaceNum) = false;
@@ -4946,56 +3851,56 @@ namespace Furnaces {
         }
 
         if (state.dataFurnaces->MyFanFlag(FurnaceNum)) {
-            if (thisFurnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
-                if (thisFurnace.ActualFanVolFlowRate > 0.0) {
-                    thisFurnace.HeatingSpeedRatio = thisFurnace.MaxHeatAirVolFlow / thisFurnace.ActualFanVolFlowRate;
-                    thisFurnace.CoolingSpeedRatio = thisFurnace.MaxCoolAirVolFlow / thisFurnace.ActualFanVolFlowRate;
-                    thisFurnace.NoHeatCoolSpeedRatio = thisFurnace.MaxNoCoolHeatAirVolFlow / thisFurnace.ActualFanVolFlowRate;
-                }
-                if (dynamic_cast<Fans::FanComponent *>(state.dataFans->fans(thisFurnace.FanIndex))->powerRatioAtSpeedRatioCurveNum > 0) {
-                    if (thisFurnace.ActualFanVolFlowRate == thisFurnace.MaxHeatAirVolFlow &&
-                        thisFurnace.ActualFanVolFlowRate == thisFurnace.MaxCoolAirVolFlow &&
-                        thisFurnace.ActualFanVolFlowRate == thisFurnace.MaxNoCoolHeatAirVolFlow) {
-                        std::string FanName = state.dataFans->fans(thisFurnace.FanIndex)->Name;
-                        ShowWarningError(state, format("{} \"{}\"", HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name));
+            if (furnace.ActualFanVolFlowRate != DataSizing::AutoSize) {
+                if (furnace.ActualFanVolFlowRate > 0.0) {
+                    furnace.HeatingSpeedRatio = furnace.MaxHeatAirVolFlow / furnace.ActualFanVolFlowRate;
+                    furnace.CoolingSpeedRatio = furnace.MaxCoolAirVolFlow / furnace.ActualFanVolFlowRate;
+                    furnace.NoHeatCoolSpeedRatio = furnace.MaxNoCoolHeatAirVolFlow / furnace.ActualFanVolFlowRate;
+                }
+                if (dynamic_cast<Fans::FanComponent *>(state.dataFans->fans(furnace.FanIndex))->powerRatioAtSpeedRatioCurveNum > 0) {
+                    if (furnace.ActualFanVolFlowRate == furnace.MaxHeatAirVolFlow &&
+                        furnace.ActualFanVolFlowRate == furnace.MaxCoolAirVolFlow &&
+                        furnace.ActualFanVolFlowRate == furnace.MaxNoCoolHeatAirVolFlow) {
+                        std::string FanName = state.dataFans->fans(furnace.FanIndex)->Name;
+                        ShowWarningError(state, format("{} \"{}\"", HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name));
                         ShowContinueError(state,
-                                          format("...For fan type and name = {} \"{}\"", HVAC::fanTypeNames[(int)thisFurnace.fanType], FanName));
+                                          format("...For fan type and name = {} \"{}\"", HVAC::fanTypeNames[(int)furnace.fanType], FanName));
                         ShowContinueError(state,
                                           "...Fan power ratio function of speed ratio curve has no impact if fan volumetric flow rate is the same as "
                                           "the unitary system volumetric flow rate.");
-                        ShowContinueError(state, format("...Fan volumetric flow rate            = {:.5R} m3/s.", thisFurnace.ActualFanVolFlowRate));
-                        ShowContinueError(state, format("...Unitary system volumetric flow rate = {:.5R} m3/s.", thisFurnace.MaxHeatAirVolFlow));
+                        ShowContinueError(state, format("...Fan volumetric flow rate            = {:.5R} m3/s.", furnace.ActualFanVolFlowRate));
+                        ShowContinueError(state, format("...Unitary system volumetric flow rate = {:.5R} m3/s.", furnace.MaxHeatAirVolFlow));
                     }
                 }
                 state.dataFurnaces->MyFanFlag(FurnaceNum) = false;
             } else {
-                thisFurnace.ActualFanVolFlowRate = state.dataFans->fans(thisFurnace.FanIndex)->maxAirFlowRate;
+                furnace.ActualFanVolFlowRate = state.dataFans->fans(furnace.FanIndex)->maxAirFlowRate;
             }
         }
 
         if (allocated(state.dataZoneEquip->ZoneEquipConfig) && state.dataFurnaces->MyCheckFlag(FurnaceNum)) {
-            int zoneNum = thisFurnace.ControlZoneNum;
-            int zoneInlet = thisFurnace.ZoneInletNode;
+            int zoneNum = furnace.ControlZoneNum;
+            int zoneInlet = furnace.ZoneInletNode;
             // setup furnace zone equipment sequence information based on finding matching air terminal
             if (state.dataZoneEquip->ZoneEquipConfig(zoneNum).EquipListIndex > 0) {
                 int coolingPriority = 0;
                 int heatingPriority = 0;
                 state.dataZoneEquip->ZoneEquipList(state.dataZoneEquip->ZoneEquipConfig(zoneNum).EquipListIndex)
                     .getPrioritiesForInletNode(state, zoneInlet, coolingPriority, heatingPriority);
-                thisFurnace.ZoneSequenceCoolingNum = coolingPriority;
-                thisFurnace.ZoneSequenceHeatingNum = heatingPriority;
+                furnace.ZoneSequenceCoolingNum = coolingPriority;
+                furnace.ZoneSequenceHeatingNum = heatingPriority;
             }
             state.dataFurnaces->MyCheckFlag(FurnaceNum) = false;
-            if (thisFurnace.ZoneSequenceCoolingNum == 0 || thisFurnace.ZoneSequenceHeatingNum == 0) {
+            if (furnace.ZoneSequenceCoolingNum == 0 || furnace.ZoneSequenceHeatingNum == 0) {
                 ShowSevereError(state,
                                 format("{} \"{}\": Airloop air terminal in the zone equipment list for zone = {} not found or is not allowed Zone "
                                        "Equipment Cooling or Heating Sequence = 0.",
-                                       HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                       thisFurnace.Name,
-                                       state.dataHeatBal->Zone(thisFurnace.ControlZoneNum).Name));
+                                       HVAC::unitarySysTypeNames[(int)furnace.type],
+                                       furnace.Name,
+                                       state.dataHeatBal->Zone(furnace.ControlZoneNum).Name));
                 ShowFatalError(state,
                                format("Subroutine InitFurnace: Errors found in getting {} input.  Preceding condition(s) causes termination.",
-                                      HVAC::unitarySysTypeNames[(int)thisFurnace.type]));
+                                      HVAC::unitarySysTypeNames[(int)furnace.type]));
             }
         }
 
@@ -5028,22 +3933,22 @@ namespace Furnaces {
                 for (int ZoneInSysIndex = 1; ZoneInSysIndex <= NumAirLoopZones; ++ZoneInSysIndex) {
                     int ZoneInletNodeNum = state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).TermUnitCoolInletNodes(ZoneInSysIndex);
                     SumOfMassFlowRateMax += state.dataLoopNodes->Node(ZoneInletNodeNum).MassFlowRateMax;
-                    if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).CoolCtrlZoneNums(ZoneInSysIndex) == thisFurnace.ControlZoneNum) {
+                    if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).CoolCtrlZoneNums(ZoneInSysIndex) == furnace.ControlZoneNum) {
                         CntrlZoneTerminalUnitMassFlowRateMax = state.dataLoopNodes->Node(ZoneInletNodeNum).MassFlowRateMax;
                     }
                 }
                 if (SumOfMassFlowRateMax != 0.0) {
                     if (CntrlZoneTerminalUnitMassFlowRateMax >= HVAC::SmallAirVolFlow) {
-                        thisFurnace.ControlZoneMassFlowFrac = CntrlZoneTerminalUnitMassFlowRateMax / SumOfMassFlowRateMax;
+                        furnace.ControlZoneMassFlowFrac = CntrlZoneTerminalUnitMassFlowRateMax / SumOfMassFlowRateMax;
                     } else {
-                        ShowSevereError(state, format("{} = {}", HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name));
+                        ShowSevereError(state, format("{} = {}", HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name));
                         ShowContinueError(state, " The Fraction of Supply Air Flow That Goes Through the Controlling Zone is set to 1.");
                     }
                     BaseSizer::reportSizerOutput(state,
-                                                 HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                 thisFurnace.Name,
+                                                 HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                 furnace.Name,
                                                  "Fraction of Supply Air Flow That Goes Through the Controlling Zone",
-                                                 thisFurnace.ControlZoneMassFlowFrac);
+                                                 furnace.ControlZoneMassFlowFrac);
                     state.dataFurnaces->MyFlowFracFlag(FurnaceNum) = false;
                 }
             }
@@ -5051,14 +3956,14 @@ namespace Furnaces {
 
         // Calculate air distribution losses
         if (!FirstHVACIteration && state.dataFurnaces->AirLoopPass == 1) {
-            int ZoneInNode = thisFurnace.ZoneInletNode;
-            MassFlowRate = state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / thisFurnace.ControlZoneMassFlowFrac;
+            int ZoneInNode = furnace.ZoneInletNode;
+            MassFlowRate = state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / furnace.ControlZoneMassFlowFrac;
             if (state.afn->distribution_simulated) {
-                DeltaMassRate = state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).MassFlowRate -
-                                state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / thisFurnace.ControlZoneMassFlowFrac;
+                DeltaMassRate = state.dataLoopNodes->Node(furnace.FurnaceOutletNode).MassFlowRate -
+                                state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / furnace.ControlZoneMassFlowFrac;
                 if (DeltaMassRate < 0.0) DeltaMassRate = 0.0;
             } else {
-                MassFlowRate = state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).MassFlowRate;
+                MassFlowRate = state.dataLoopNodes->Node(furnace.FurnaceOutletNode).MassFlowRate;
                 DeltaMassRate = 0.0;
             }
             Real64 TotalOutput(0.0);         // total output rate, {W}
@@ -5066,58 +3971,58 @@ namespace Furnaces {
             Real64 LatentOutputDelta(0.0);   // delta latent output rate, {W}
             Real64 TotalOutputDelta(0.0);    // delta total output rate, {W}
             CalcZoneSensibleLatentOutput(MassFlowRate,
-                                         state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).Temp,
-                                         state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).HumRat,
+                                         state.dataLoopNodes->Node(furnace.FurnaceOutletNode).Temp,
+                                         state.dataLoopNodes->Node(furnace.FurnaceOutletNode).HumRat,
                                          state.dataLoopNodes->Node(ZoneInNode).Temp,
                                          state.dataLoopNodes->Node(ZoneInNode).HumRat,
-                                         thisFurnace.SenLoadLoss,
-                                         thisFurnace.LatLoadLoss,
+                                         furnace.SenLoadLoss,
+                                         furnace.LatLoadLoss,
                                          TotalOutput);
             CalcZoneSensibleLatentOutput(DeltaMassRate,
-                                         state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).Temp,
-                                         state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).HumRat,
-                                         state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).Temp,
-                                         state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).HumRat,
+                                         state.dataLoopNodes->Node(furnace.FurnaceOutletNode).Temp,
+                                         state.dataLoopNodes->Node(furnace.FurnaceOutletNode).HumRat,
+                                         state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).Temp,
+                                         state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).HumRat,
                                          SensibleOutputDelta,
                                          LatentOutputDelta,
                                          TotalOutputDelta);
-            thisFurnace.SenLoadLoss = thisFurnace.SenLoadLoss + SensibleOutputDelta;
-            if (std::abs(thisFurnace.SensibleLoadMet) > 0.0) {
-                if (std::abs(thisFurnace.SenLoadLoss / thisFurnace.SensibleLoadMet) < 0.001) thisFurnace.SenLoadLoss = 0.0;
+            furnace.SenLoadLoss = furnace.SenLoadLoss + SensibleOutputDelta;
+            if (std::abs(furnace.SensibleLoadMet) > 0.0) {
+                if (std::abs(furnace.SenLoadLoss / furnace.SensibleLoadMet) < 0.001) furnace.SenLoadLoss = 0.0;
             }
-            if (thisFurnace.Humidistat) {
-                thisFurnace.LatLoadLoss = thisFurnace.LatLoadLoss + LatentOutputDelta;
-                if (std::abs(thisFurnace.LatentLoadMet) > 0.0) {
-                    if (std::abs(thisFurnace.LatLoadLoss / thisFurnace.LatentLoadMet) < 0.001) thisFurnace.LatLoadLoss = 0.0;
+            if (furnace.Humidistat) {
+                furnace.LatLoadLoss = furnace.LatLoadLoss + LatentOutputDelta;
+                if (std::abs(furnace.LatentLoadMet) > 0.0) {
+                    if (std::abs(furnace.LatLoadLoss / furnace.LatentLoadMet) < 0.001) furnace.LatLoadLoss = 0.0;
                 }
             }
         }
 
-        if (thisFurnace.fanOpModeSched != nullptr) {
-            thisFurnace.fanOp = (thisFurnace.fanOpModeSched->getCurrentVal() == 0.0) ? HVAC::FanOp::Cycling : HVAC::FanOp::Continuous;
+        if (furnace.fanOpModeSched != nullptr) {
+            furnace.fanOp = (furnace.fanOpModeSched->getCurrentVal() == 0.0) ? HVAC::FanOp::Cycling : HVAC::FanOp::Continuous;
             if (AirLoopNum > 0) {
-                state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = thisFurnace.fanOp;
+                state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = furnace.fanOp;
             }
         }
 
-        fanOp = thisFurnace.fanOp;
+        fanOp = furnace.fanOp;
         state.dataFurnaces->EconomizerFlag = state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive;
 
-        if (thisFurnace.ControlZoneMassFlowFrac > 0.0) {
-            QZnReq = ZoneLoad / thisFurnace.ControlZoneMassFlowFrac;
-            MoistureLoad /= thisFurnace.ControlZoneMassFlowFrac;
+        if (furnace.ControlZoneMassFlowFrac > 0.0) {
+            QZnReq = ZoneLoad / furnace.ControlZoneMassFlowFrac;
+            MoistureLoad /= furnace.ControlZoneMassFlowFrac;
             ZoneLoad = QZnReq;
         } else {
             QZnReq = ZoneLoad;
         }
 
         // Original thermostat control logic (works only for cycling fan systems)
-        if (QZnReq > HVAC::SmallLoad && QZnReq > (Small5WLoad / thisFurnace.ControlZoneMassFlowFrac) &&
-            !state.dataZoneEnergyDemand->CurDeadBandOrSetback(thisFurnace.ControlZoneNum)) {
+        if (QZnReq > HVAC::SmallLoad && QZnReq > (Small5WLoad / furnace.ControlZoneMassFlowFrac) &&
+            !state.dataZoneEnergyDemand->CurDeadBandOrSetback(furnace.ControlZoneNum)) {
             state.dataFurnaces->HeatingLoad = true;
             state.dataFurnaces->CoolingLoad = false;
-        } else if (QZnReq < -HVAC::SmallLoad && std::abs(QZnReq) > (Small5WLoad / thisFurnace.ControlZoneMassFlowFrac) &&
-                   !state.dataZoneEnergyDemand->CurDeadBandOrSetback(thisFurnace.ControlZoneNum)) {
+        } else if (QZnReq < -HVAC::SmallLoad && std::abs(QZnReq) > (Small5WLoad / furnace.ControlZoneMassFlowFrac) &&
+                   !state.dataZoneEnergyDemand->CurDeadBandOrSetback(furnace.ControlZoneNum)) {
             state.dataFurnaces->HeatingLoad = false;
             state.dataFurnaces->CoolingLoad = true;
         } else {
@@ -5125,10 +4030,10 @@ namespace Furnaces {
             state.dataFurnaces->CoolingLoad = false;
         }
 
-        if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-            (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir &&
-             (thisFurnace.WatertoAirHPType == WAHPCoilType::Simple || thisFurnace.WatertoAirHPType == WAHPCoilType::VarSpeedEquationFit))) {
-            if (MoistureLoad < 0.0 && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+        if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+            (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir &&
+             (furnace.WatertoAirHPType == WAHPCoilType::Simple || furnace.WatertoAirHPType == WAHPCoilType::VarSpeedEquationFit))) {
+            if (MoistureLoad < 0.0 && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
                 state.dataFurnaces->HPDehumidificationLoadFlag = true;
                 state.dataFurnaces->HeatingLoad = false;
                 state.dataFurnaces->CoolingLoad = true;
@@ -5138,10 +4043,10 @@ namespace Furnaces {
         }
 
         // Check for heat only furnace
-        if (thisFurnace.type != HVAC::UnitarySysType::Furnace_HeatOnly && thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatOnly) {
+        if (furnace.type != HVAC::UnitarySysType::Furnace_HeatOnly && furnace.type != HVAC::UnitarySysType::Unitary_HeatOnly) {
 
-            if (thisFurnace.availSched->getCurrentVal() > 0.0) {
-                if ((state.dataFurnaces->HeatingLoad || state.dataFurnaces->CoolingLoad) || (thisFurnace.Humidistat && MoistureLoad < 0.0)) {
+            if (furnace.availSched->getCurrentVal() > 0.0) {
+                if ((state.dataFurnaces->HeatingLoad || state.dataFurnaces->CoolingLoad) || (furnace.Humidistat && MoistureLoad < 0.0)) {
                     PartLoadRatio = 1.0;
                 } else {
                     PartLoadRatio = 0.0;
@@ -5156,193 +4061,192 @@ namespace Furnaces {
         // get current time step operating capacity of water and steam coils
         // (dependent on entering water and steam temperature)
         if (FirstHVACIteration) {
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWater) {
                 // set water-side mass flow rates
-                state.dataLoopNodes->Node(thisFurnace.HWCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
-                mdot = thisFurnace.MaxHeatCoilFluidFlow;
-                PlantUtilities::SetComponentFlowRate(state, mdot, thisFurnace.CoilControlNode, thisFurnace.CoilOutletNode, thisFurnace.plantLoc);
+                state.dataLoopNodes->Node(furnace.HeatCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
+                mdot = furnace.MaxHeatCoilFluidFlow;
+                PlantUtilities::SetComponentFlowRate(state, mdot, furnace.HeatCoilControlNode, furnace.CoilOutletNode, furnace.plantLoc);
                 //     simulate water coil to find operating capacity
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, thisFurnace.HeatingCoilName, FirstHVACIteration, thisFurnace.HeatingCoilIndex, QActual);
-                thisFurnace.DesignHeatingCapacity = QActual;
+                    state, furnace.HeatCoilName, FirstHVACIteration, furnace.HeatCoilNum, QActual);
+                furnace.DesignHeatingCapacity = QActual;
 
-            } // from IF(furnace%HeatingCoilType_Num == Coil_HeatingWater) THEN
+            } // from IF(furnace%heatCoilType == Coil_HeatingWater) THEN
 
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingSteam) {
                 // set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(thisFurnace.HWCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
-                mdot = thisFurnace.MaxHeatCoilFluidFlow;
-                PlantUtilities::SetComponentFlowRate(state, mdot, thisFurnace.CoilControlNode, thisFurnace.CoilOutletNode, thisFurnace.plantLoc);
+                state.dataLoopNodes->Node(furnace.HeatCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
+                mdot = furnace.MaxHeatCoilFluidFlow;
+                PlantUtilities::SetComponentFlowRate(state, mdot, furnace.HeatCoilControlNode, furnace.CoilOutletNode, furnace.plantLoc);
 
                 //     simulate steam coil to find operating capacity
                 SteamCoils::SimulateSteamCoilComponents(state,
-                                                        thisFurnace.HeatingCoilName,
+                                                        furnace.HeatCoilName,
                                                         FirstHVACIteration,
-                                                        thisFurnace.HeatingCoilIndex,
+                                                        furnace.HeatCoilNum,
                                                         1.0,
                                                         QActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                thisFurnace.DesignHeatingCapacity =
-                    SteamCoils::GetCoilCapacity(state, thisFurnace.HeatingCoilType, thisFurnace.HeatingCoilName, ErrorsFound);
+                furnace.DesignHeatingCapacity = SteamCoils::GetCoilCapacity(state, furnace.HeatCoilNum);
 
-            } // from IF(Furnace(FurnaceNum)%HeatingCoilType_Num == Coil_HeatingSteam) THEN
+            } // from IF(Furnace(FurnaceNum)%heatCoilType == Coil_HeatingSteam) THEN
 
-            if (thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
 
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(thisFurnace.SuppCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
-                mdot = thisFurnace.MaxSuppCoilFluidFlow;
+                state.dataLoopNodes->Node(furnace.SuppCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
+                mdot = furnace.MaxSuppCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, thisFurnace.SuppCoilControlNode, thisFurnace.SuppCoilOutletNode, thisFurnace.SuppPlantLoc);
+                    state, mdot, furnace.SuppCoilControlNode, furnace.SuppCoilOutletNode, furnace.SuppPlantLoc);
 
                 //     simulate water coil to find operating capacity
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, thisFurnace.SuppHeatCoilName, FirstHVACIteration, thisFurnace.SuppHeatCoilIndex, QActual);
-                thisFurnace.DesignSuppHeatingCapacity = QActual;
+                    state, furnace.SuppCoilName, FirstHVACIteration, furnace.SuppCoilNum, QActual);
+                furnace.DesignSuppHeatingCapacity = QActual;
 
-            } // from IF(Furnace(FurnaceNum)%SuppHeatCoilType_Num == Coil_HeatingWater) THEN
-            if (thisFurnace.SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+            } // from IF(Furnace(FurnaceNum)%suppHeatCoilType == Coil_HeatingWater) THEN
+            if (furnace.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(thisFurnace.SuppCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
-                mdot = thisFurnace.MaxSuppCoilFluidFlow;
+                state.dataLoopNodes->Node(furnace.SuppCoilAirInletNode).MassFlowRate = state.dataFurnaces->CompOnMassFlow;
+                mdot = furnace.MaxSuppCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
-                    state, mdot, thisFurnace.SuppCoilControlNode, thisFurnace.SuppCoilOutletNode, thisFurnace.SuppPlantLoc);
+                    state, mdot, furnace.SuppCoilControlNode, furnace.SuppCoilOutletNode, furnace.SuppPlantLoc);
 
                 //     simulate steam coil to find operating capacity
                 SteamCoils::SimulateSteamCoilComponents(state,
-                                                        thisFurnace.SuppHeatCoilName,
+                                                        furnace.SuppCoilName,
                                                         FirstHVACIteration,
-                                                        thisFurnace.SuppHeatCoilIndex,
+                                                        furnace.SuppCoilNum,
                                                         1.0,
                                                         QActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                thisFurnace.DesignSuppHeatingCapacity =
-                    SteamCoils::GetCoilCapacity(state, thisFurnace.SuppHeatCoilType, thisFurnace.SuppHeatCoilName, ErrorsFound);
+                furnace.DesignSuppHeatingCapacity = SteamCoils::GetCoilCapacity(state, furnace.SuppCoilNum);
 
-            } // from IF(Furnace(FurnaceNum)%SuppHeatCoilType_Num == Coil_HeatingSteam) THEN
+            } // from IF(Furnace(FurnaceNum)%suppHeatCoilType == Coil_HeatingSteam) THEN
         }     // from IF( FirstHVACIteration ) THEN
 
-        if (thisFurnace.NumOfSpeedCooling > 0) { // BoS, variable-speed water source hp
+        if (furnace.NumOfSpeedCooling > 0) { // BoS, variable-speed water source hp
             // Furnace(FurnaceNum)%IdleMassFlowRate = RhoAir*Furnace(FurnaceNum)%IdleVolumeAirRate
-            int NumOfSpeedCooling = thisFurnace.NumOfSpeedCooling;
-            int NumOfSpeedHeating = thisFurnace.NumOfSpeedHeating;
+            int NumOfSpeedCooling = furnace.NumOfSpeedCooling;
+            int NumOfSpeedHeating = furnace.NumOfSpeedHeating;
             // IF MSHP system was not autosized and the fan is autosized, check that fan volumetric flow rate is greater than MSHP flow rates
-            if (thisFurnace.CheckFanFlow) {
+            if (furnace.CheckFanFlow) {
                 state.dataFurnaces->CurrentModuleObject = "AirLoopHVAC:UnitaryHeatPump:VariableSpeed";
-                thisFurnace.FanVolFlow = state.dataFans->fans(thisFurnace.FanIndex)->maxAirFlowRate;
+                furnace.FanVolFlow = state.dataFans->fans(furnace.FanIndex)->maxAirFlowRate;
 
-                if (thisFurnace.FanVolFlow != DataSizing::AutoSize) {
+                if (furnace.FanVolFlow != DataSizing::AutoSize) {
                     //     Check fan versus system supply air flow rates
-                    if (thisFurnace.FanVolFlow + 1e-10 < thisFurnace.CoolVolumeFlowRate(NumOfSpeedCooling)) {
+                    if (furnace.FanVolFlow + 1e-10 < furnace.CoolVolumeFlowRate(NumOfSpeedCooling)) {
                         ShowWarningError(state,
                                          format("{} - air flow rate = {:.7T} in fan object is less than the MSHP system air flow rate when cooling "
                                                 "is required ({:.7T}).",
                                                 state.dataFurnaces->CurrentModuleObject,
-                                                thisFurnace.FanVolFlow,
-                                                thisFurnace.CoolVolumeFlowRate(NumOfSpeedCooling)));
+                                                furnace.FanVolFlow,
+                                                furnace.CoolVolumeFlowRate(NumOfSpeedCooling)));
                         ShowContinueError(
                             state, " The MSHP system flow rate when cooling is required is reset to the fan flow rate and the simulation continues.");
-                        ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, thisFurnace.Name));
-                        thisFurnace.CoolVolumeFlowRate(NumOfSpeedCooling) = thisFurnace.FanVolFlow;
+                        ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, furnace.Name));
+                        furnace.CoolVolumeFlowRate(NumOfSpeedCooling) = furnace.FanVolFlow;
 
-                        if (thisFurnace.bIsIHP) // set max fan flow rate to the IHP collection
+                        if (furnace.isIHP) // set max fan flow rate to the IHP collection
                         {
-                            state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).MaxCoolAirVolFlow = thisFurnace.FanVolFlow;
-                            state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).MaxCoolAirMassFlow =
-                                thisFurnace.FanVolFlow * state.dataEnvrn->StdRhoAir;
+                            state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).MaxCoolAirVolFlow = furnace.FanVolFlow;
+                            state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).MaxCoolAirMassFlow =
+                                furnace.FanVolFlow * state.dataEnvrn->StdRhoAir;
                         }
 
                         // Check flow rates in other speeds and ensure flow rates are not above the max flow rate
                         for (int i = NumOfSpeedCooling - 1; i >= 1; --i) {
-                            if (thisFurnace.CoolVolumeFlowRate(i) > thisFurnace.CoolVolumeFlowRate(i + 1)) {
+                            if (furnace.CoolVolumeFlowRate(i) > furnace.CoolVolumeFlowRate(i + 1)) {
                                 ShowContinueError(state,
                                                   format(" The MSHP system flow rate when cooling is required is reset to the flow rate at higher "
                                                          "speed and the simulation continues at Speed{}.",
                                                          i));
-                                ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, thisFurnace.Name));
-                                thisFurnace.CoolVolumeFlowRate(i) = thisFurnace.CoolVolumeFlowRate(i + 1);
+                                ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, furnace.Name));
+                                furnace.CoolVolumeFlowRate(i) = furnace.CoolVolumeFlowRate(i + 1);
                             }
                         }
                     }
                     if (NumOfSpeedHeating > 0) {
-                        if (thisFurnace.FanVolFlow + 1e-10 < thisFurnace.HeatVolumeFlowRate(NumOfSpeedHeating)) {
+                        if (furnace.FanVolFlow + 1e-10 < furnace.HeatVolumeFlowRate(NumOfSpeedHeating)) {
                             ShowWarningError(state,
                                              format("{} - air flow rate = {:.7T} in fan object is less than the MSHP system air flow rate when "
                                                     "heating is required ({:.7T}).",
                                                     state.dataFurnaces->CurrentModuleObject,
-                                                    thisFurnace.FanVolFlow,
-                                                    thisFurnace.HeatVolumeFlowRate(NumOfSpeedHeating)));
+                                                    furnace.FanVolFlow,
+                                                    furnace.HeatVolumeFlowRate(NumOfSpeedHeating)));
                             ShowContinueError(
                                 state,
                                 " The MSHP system flow rate when heating is required is reset to the fan flow rate and the simulation continues.");
-                            ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, thisFurnace.Name));
-                            thisFurnace.HeatVolumeFlowRate(NumOfSpeedHeating) = thisFurnace.FanVolFlow;
+                            ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, furnace.Name));
+                            furnace.HeatVolumeFlowRate(NumOfSpeedHeating) = furnace.FanVolFlow;
 
-                            if (thisFurnace.bIsIHP) // set max fan flow rate to the IHP collection
+                            if (furnace.isIHP) // set max fan flow rate to the IHP collection
                             {
-                                state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).MaxHeatAirVolFlow = thisFurnace.FanVolFlow;
-                                state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).MaxHeatAirMassFlow =
-                                    thisFurnace.FanVolFlow * state.dataEnvrn->StdRhoAir;
+                                // ihpIndex is the index of the IHP, CoolCoilNum is the index of the coil in the IHP
+                                state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).MaxHeatAirVolFlow = furnace.FanVolFlow;
+                                state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).MaxHeatAirMassFlow =
+                                    furnace.FanVolFlow * state.dataEnvrn->StdRhoAir;
                             }
 
                             for (int i = NumOfSpeedHeating - 1; i >= 1; --i) {
-                                if (thisFurnace.HeatVolumeFlowRate(i) > thisFurnace.HeatVolumeFlowRate(i + 1)) {
+                                if (furnace.HeatVolumeFlowRate(i) > furnace.HeatVolumeFlowRate(i + 1)) {
                                     ShowContinueError(state,
                                                       format(" The MSHP system flow rate when heating is required is reset to the flow rate at "
                                                              "higher speed and the simulation continues at Speed{}.",
                                                              i));
                                     ShowContinueError(state,
-                                                      format(" Occurs in {} system = {}", state.dataFurnaces->CurrentModuleObject, thisFurnace.Name));
-                                    thisFurnace.HeatVolumeFlowRate(i) = thisFurnace.HeatVolumeFlowRate(i + 1);
+                                                      format(" Occurs in {} system = {}", state.dataFurnaces->CurrentModuleObject, furnace.Name));
+                                    furnace.HeatVolumeFlowRate(i) = furnace.HeatVolumeFlowRate(i + 1);
                                 }
                             }
                         }
                     }
-                    if (thisFurnace.FanVolFlow < thisFurnace.IdleVolumeAirRate && thisFurnace.IdleVolumeAirRate != 0.0) {
+                    if (furnace.FanVolFlow < furnace.IdleVolumeAirRate && furnace.IdleVolumeAirRate != 0.0) {
                         ShowWarningError(state,
                                          format("{} - air flow rate = {:.7T} in fan object is less than the MSHP system air flow rate when no "
                                                 "heating or cooling is needed ({:.7T}).",
                                                 state.dataFurnaces->CurrentModuleObject,
-                                                thisFurnace.FanVolFlow,
-                                                thisFurnace.IdleVolumeAirRate));
+                                                furnace.FanVolFlow,
+                                                furnace.IdleVolumeAirRate));
                         ShowContinueError(state,
                                           " The MSHP system flow rate when no heating or cooling is needed is reset to the fan flow rate and the "
                                           "simulation continues.");
-                        ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, thisFurnace.Name));
-                        thisFurnace.IdleVolumeAirRate = thisFurnace.FanVolFlow;
+                        ShowContinueError(state, format(" Occurs in {} = {}", state.dataFurnaces->CurrentModuleObject, furnace.Name));
+                        furnace.IdleVolumeAirRate = furnace.FanVolFlow;
                     }
                     RhoAir = state.dataEnvrn->StdRhoAir;
                     // set the mass flow rates from the reset volume flow rates
                     for (int i = 1; i <= NumOfSpeedCooling; ++i) {
-                        thisFurnace.CoolMassFlowRate(i) = RhoAir * thisFurnace.CoolVolumeFlowRate(i);
-                        if (thisFurnace.FanVolFlow > 0.0) {
-                            thisFurnace.MSCoolingSpeedRatio(i) = thisFurnace.CoolVolumeFlowRate(i) / thisFurnace.FanVolFlow;
+                        furnace.CoolMassFlowRate(i) = RhoAir * furnace.CoolVolumeFlowRate(i);
+                        if (furnace.FanVolFlow > 0.0) {
+                            furnace.MSCoolingSpeedRatio(i) = furnace.CoolVolumeFlowRate(i) / furnace.FanVolFlow;
                         }
                     }
                     for (int i = 1; i <= NumOfSpeedHeating; ++i) {
-                        thisFurnace.HeatMassFlowRate(i) = RhoAir * thisFurnace.HeatVolumeFlowRate(i);
-                        if (thisFurnace.FanVolFlow > 0.0) {
-                            thisFurnace.MSHeatingSpeedRatio(i) = thisFurnace.HeatVolumeFlowRate(i) / thisFurnace.FanVolFlow;
+                        furnace.HeatMassFlowRate(i) = RhoAir * furnace.HeatVolumeFlowRate(i);
+                        if (furnace.FanVolFlow > 0.0) {
+                            furnace.MSHeatingSpeedRatio(i) = furnace.HeatVolumeFlowRate(i) / furnace.FanVolFlow;
                         }
                     }
-                    thisFurnace.IdleMassFlowRate = RhoAir * thisFurnace.IdleVolumeAirRate;
-                    if (thisFurnace.FanVolFlow > 0.0) {
-                        thisFurnace.IdleSpeedRatio = thisFurnace.IdleVolumeAirRate / thisFurnace.FanVolFlow;
+                    furnace.IdleMassFlowRate = RhoAir * furnace.IdleVolumeAirRate;
+                    if (furnace.FanVolFlow > 0.0) {
+                        furnace.IdleSpeedRatio = furnace.IdleVolumeAirRate / furnace.FanVolFlow;
                     }
                     // set the node max and min mass flow rates based on reset volume flow rates
                     if (NumOfSpeedCooling > 0 && NumOfSpeedHeating == 0) {
                         state.dataLoopNodes->Node(InNode).MassFlowRateMax =
-                            max(thisFurnace.CoolMassFlowRate(NumOfSpeedCooling), thisFurnace.MaxHeatAirMassFlow);
+                            max(furnace.CoolMassFlowRate(NumOfSpeedCooling), furnace.MaxHeatAirMassFlow);
                         state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail =
-                            max(thisFurnace.CoolMassFlowRate(NumOfSpeedCooling), thisFurnace.MaxHeatAirMassFlow);
+                            max(furnace.CoolMassFlowRate(NumOfSpeedCooling), furnace.MaxHeatAirMassFlow);
                     } else if (NumOfSpeedCooling == 0 && NumOfSpeedHeating > 0) {
                         state.dataLoopNodes->Node(InNode).MassFlowRateMax =
-                            max(thisFurnace.MaxCoolAirMassFlow, thisFurnace.HeatMassFlowRate(NumOfSpeedHeating));
+                            max(furnace.MaxCoolAirMassFlow, furnace.HeatMassFlowRate(NumOfSpeedHeating));
                         state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail =
-                            max(thisFurnace.MaxCoolAirMassFlow, thisFurnace.HeatMassFlowRate(NumOfSpeedHeating));
+                            max(furnace.MaxCoolAirMassFlow, furnace.HeatMassFlowRate(NumOfSpeedHeating));
                     } else {
                         state.dataLoopNodes->Node(InNode).MassFlowRateMax =
-                            max(thisFurnace.CoolMassFlowRate(NumOfSpeedCooling), thisFurnace.HeatMassFlowRate(NumOfSpeedHeating));
+                            max(furnace.CoolMassFlowRate(NumOfSpeedCooling), furnace.HeatMassFlowRate(NumOfSpeedHeating));
                         state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail =
-                            max(thisFurnace.CoolMassFlowRate(NumOfSpeedCooling), thisFurnace.HeatMassFlowRate(NumOfSpeedHeating));
+                            max(furnace.CoolMassFlowRate(NumOfSpeedCooling), furnace.HeatMassFlowRate(NumOfSpeedHeating));
                     }
                     state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
                     state.dataLoopNodes->Node(InNode).MassFlowRateMinAvail = 0.0;
@@ -5350,7 +4254,7 @@ namespace Furnaces {
                 }
             }
 
-            thisFurnace.CheckFanFlow = false;
+            furnace.CheckFanFlow = false;
         }
         SetOnOffMassFlowRate(state, FurnaceNum, AirLoopNum, OnOffAirFlowRatio, fanOp, QZnReq, MoistureLoad, PartLoadRatio);
 
@@ -5359,10 +4263,10 @@ namespace Furnaces {
 
         QToCoolSetPt = 0.0;
         QToHeatSetPt = 0.0;
-        if (fanOp == HVAC::FanOp::Continuous && thisFurnace.availSched->getCurrentVal() > 0.0 &&
-            ((thisFurnace.fanAvailSched->getCurrentVal() > 0.0 || state.dataHVACGlobal->TurnFansOn) && !state.dataHVACGlobal->TurnFansOff)) {
+        if (fanOp == HVAC::FanOp::Continuous && furnace.availSched->getCurrentVal() > 0.0 &&
+            ((furnace.fanAvailSched->getCurrentVal() > 0.0 || state.dataHVACGlobal->TurnFansOn) && !state.dataHVACGlobal->TurnFansOff)) {
 
-            if (thisFurnace.NumOfSpeedCooling > 0) {
+            if (furnace.NumOfSpeedCooling > 0) {
                 CalcVarSpeedHeatPump(state,
                                      FurnaceNum,
                                      false,
@@ -5392,43 +4296,43 @@ namespace Furnaces {
                                   false);
             }
 
-            if (thisFurnace.ControlZoneMassFlowFrac > 0.0) {
-                if (thisFurnace.ZoneSequenceCoolingNum > 0 && thisFurnace.ZoneSequenceHeatingNum > 0) {
-                    QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum)
-                                       .SequencedOutputRequiredToCoolingSP(thisFurnace.ZoneSequenceCoolingNum) /
-                                   thisFurnace.ControlZoneMassFlowFrac;
-                    QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum)
-                                       .SequencedOutputRequiredToHeatingSP(thisFurnace.ZoneSequenceHeatingNum) /
-                                   thisFurnace.ControlZoneMassFlowFrac;
+            if (furnace.ControlZoneMassFlowFrac > 0.0) {
+                if (furnace.ZoneSequenceCoolingNum > 0 && furnace.ZoneSequenceHeatingNum > 0) {
+                    QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum)
+                                       .SequencedOutputRequiredToCoolingSP(furnace.ZoneSequenceCoolingNum) /
+                                   furnace.ControlZoneMassFlowFrac;
+                    QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum)
+                                       .SequencedOutputRequiredToHeatingSP(furnace.ZoneSequenceHeatingNum) /
+                                   furnace.ControlZoneMassFlowFrac;
                 } else {
-                    QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum).OutputRequiredToCoolingSP /
-                                   thisFurnace.ControlZoneMassFlowFrac;
-                    QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum).OutputRequiredToHeatingSP /
-                                   thisFurnace.ControlZoneMassFlowFrac;
+                    QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum).OutputRequiredToCoolingSP /
+                                   furnace.ControlZoneMassFlowFrac;
+                    QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum).OutputRequiredToHeatingSP /
+                                   furnace.ControlZoneMassFlowFrac;
                 }
                 //     If the furnace has a net cooling capacity (SensibleOutput < 0) and
                 //     the zone temp is above the Tstat heating setpoint (QToHeatSetPt < 0) and
                 //     the net cooling capacity does not just offset the cooling load
                 if (SensibleOutput < 0.0 && QToHeatSetPt < 0.0 &&
-                    std::abs(QToCoolSetPt - SensibleOutput) > (Small5WLoad / thisFurnace.ControlZoneMassFlowFrac)) {
+                    std::abs(QToCoolSetPt - SensibleOutput) > (Small5WLoad / furnace.ControlZoneMassFlowFrac)) {
                     //       Only switch modes when humidistat is not used or no moisture load exists, otherwise let
                     //       reheat coil pick up load
                     //        IF((SensibleOutput .LT. QToHeatSetPt .AND. .NOT. Furnace(FurnaceNum)%Humidistat) .OR. &
                     //           (SensibleOutput .LT. QToHeatSetPt .AND. Furnace(FurnaceNum)%Humidistat .AND. MoistureLoad .GE. 0.0))THEN
-                    if ((SensibleOutput < QToHeatSetPt && !thisFurnace.Humidistat) ||
-                        (SensibleOutput < QToHeatSetPt && thisFurnace.Humidistat && MoistureLoad >= 0.0)) {
+                    if ((SensibleOutput < QToHeatSetPt && !furnace.Humidistat) ||
+                        (SensibleOutput < QToHeatSetPt && furnace.Humidistat && MoistureLoad >= 0.0)) {
                         QZnReq = QToHeatSetPt;
                         state.dataFurnaces->CoolingLoad = false;
                         //         Don't set mode TRUE unless mode is allowed. Also check for floating zone.
-                        if (state.dataHeatBalFanSys->TempControlType(thisFurnace.ControlZoneNum) == HVAC::SetptType::SingleCool ||
-                            state.dataHeatBalFanSys->TempControlType(thisFurnace.ControlZoneNum) == HVAC::SetptType::Uncontrolled) {
+                        if (state.dataHeatBalFanSys->TempControlType(furnace.ControlZoneNum) == HVAC::SetptType::SingleCool ||
+                            state.dataHeatBalFanSys->TempControlType(furnace.ControlZoneNum) == HVAC::SetptType::Uncontrolled) {
                             state.dataFurnaces->HeatingLoad = false;
                         } else {
                             state.dataFurnaces->HeatingLoad = true;
                         }
 
                         SetOnOffMassFlowRate(state, FurnaceNum, AirLoopNum, OnOffAirFlowRatio, fanOp, QZnReq, MoistureLoad, PartLoadRatio);
-                        if (thisFurnace.NumOfSpeedCooling > 0) {
+                        if (furnace.NumOfSpeedCooling > 0) {
                             CalcVarSpeedHeatPump(state,
                                                  FurnaceNum,
                                                  false,
@@ -5476,7 +4380,7 @@ namespace Furnaces {
                     }
                     // the net cooling capacity just offsets the cooling load, turn off cooling
                 } else if (SensibleOutput < 0.0 && QToCoolSetPt < 0.0 &&
-                           std::abs(QToCoolSetPt - SensibleOutput) < (Small5WLoad / thisFurnace.ControlZoneMassFlowFrac)) {
+                           std::abs(QToCoolSetPt - SensibleOutput) < (Small5WLoad / furnace.ControlZoneMassFlowFrac)) {
                     state.dataFurnaces->CoolingLoad = false;
                     if (state.dataFurnaces->HPDehumidificationLoadFlag) {
                         state.dataFurnaces->CoolingLoad = true;
@@ -5487,12 +4391,12 @@ namespace Furnaces {
                 //     If the furnace has a net heating capacity and the zone temp is below the Tstat cooling setpoint and
                 //     the net heating capacity does not just offset the heating load
                 if (SensibleOutput > 0.0 && QToCoolSetPt > 0.0 &&
-                    std::abs(SensibleOutput - QToHeatSetPt) > (Small5WLoad / thisFurnace.ControlZoneMassFlowFrac)) {
+                    std::abs(SensibleOutput - QToHeatSetPt) > (Small5WLoad / furnace.ControlZoneMassFlowFrac)) {
                     if (SensibleOutput > QToCoolSetPt) {
                         QZnReq = QToCoolSetPt;
                         //         Don't set mode TRUE unless mode is allowed. Also check for floating zone.
-                        if (state.dataHeatBalFanSys->TempControlType(thisFurnace.ControlZoneNum) == HVAC::SetptType::SingleHeat ||
-                            state.dataHeatBalFanSys->TempControlType(thisFurnace.ControlZoneNum) == HVAC::SetptType::Uncontrolled) {
+                        if (state.dataHeatBalFanSys->TempControlType(furnace.ControlZoneNum) == HVAC::SetptType::SingleHeat ||
+                            state.dataHeatBalFanSys->TempControlType(furnace.ControlZoneNum) == HVAC::SetptType::Uncontrolled) {
                             state.dataFurnaces->CoolingLoad = false;
                         } else {
                             state.dataFurnaces->CoolingLoad = true;
@@ -5500,7 +4404,7 @@ namespace Furnaces {
                         state.dataFurnaces->HeatingLoad = false;
 
                         SetOnOffMassFlowRate(state, FurnaceNum, AirLoopNum, OnOffAirFlowRatio, fanOp, QZnReq, MoistureLoad, PartLoadRatio);
-                        if (thisFurnace.NumOfSpeedCooling > 0) {
+                        if (furnace.NumOfSpeedCooling > 0) {
                             CalcVarSpeedHeatPump(state,
                                                  FurnaceNum,
                                                  false,
@@ -5548,7 +4452,7 @@ namespace Furnaces {
                     }
                     //     the net heating capacity just offsets the heating load, turn off heating
                 } else if (SensibleOutput > 0.0 && QToHeatSetPt > 0.0 &&
-                           std::abs(SensibleOutput - QToHeatSetPt) < (Small5WLoad / thisFurnace.ControlZoneMassFlowFrac)) {
+                           std::abs(SensibleOutput - QToHeatSetPt) < (Small5WLoad / furnace.ControlZoneMassFlowFrac)) {
                     state.dataFurnaces->HeatingLoad = false;
                 } // SensibleOutput .GT. 0.0d0 .AND. QToCoolSetPt .GT. 0.0d0
             }     // Furnace(FurnaceNum)%ControlZoneMassFlowFrac .GT. 0.0d0
@@ -5556,20 +4460,20 @@ namespace Furnaces {
         } // fanOp .EQ. FanOp::Continuous
 
         if (FirstHVACIteration) {
-            thisFurnace.iterationCounter = 0;
-            thisFurnace.iterationMode = Furnaces::ModeOfOperation::NoCoolHeat;
+            furnace.iterationCounter = 0;
+            furnace.iterationMode = Furnaces::ModeOfOperation::NoCoolHeat;
         }
-        thisFurnace.iterationCounter += 1;
+        furnace.iterationCounter += 1;
 
         // push iteration mode stack and set current mode
-        thisFurnace.iterationMode(3) = thisFurnace.iterationMode(2);
-        thisFurnace.iterationMode(2) = thisFurnace.iterationMode(1);
+        furnace.iterationMode(3) = furnace.iterationMode(2);
+        furnace.iterationMode(2) = furnace.iterationMode(1);
         if (state.dataFurnaces->CoolingLoad) {
-            thisFurnace.iterationMode(1) = Furnaces::ModeOfOperation::CoolingMode;
+            furnace.iterationMode(1) = Furnaces::ModeOfOperation::CoolingMode;
         } else if (state.dataFurnaces->HeatingLoad) {
-            thisFurnace.iterationMode(1) = Furnaces::ModeOfOperation::HeatingMode;
+            furnace.iterationMode(1) = Furnaces::ModeOfOperation::HeatingMode;
         } else {
-            thisFurnace.iterationMode(1) = Furnaces::ModeOfOperation::NoCoolHeat;
+            furnace.iterationMode(1) = Furnaces::ModeOfOperation::NoCoolHeat;
         }
 
         // IF small loads to meet or not converging, just shut down unit
@@ -5577,11 +4481,11 @@ namespace Furnaces {
             ZoneLoad = 0.0;
             state.dataFurnaces->CoolingLoad = false;
             state.dataFurnaces->HeatingLoad = false;
-        } else if (thisFurnace.iterationCounter > (state.dataHVACGlobal->MinAirLoopIterationsAfterFirst + 4)) {
+        } else if (furnace.iterationCounter > (state.dataHVACGlobal->MinAirLoopIterationsAfterFirst + 4)) {
             // attempt to lock output (air flow) if oscillations are detected
-            OperatingMode = thisFurnace.iterationMode(1);
-            OperatingModeMinusOne = thisFurnace.iterationMode(2);
-            OperatingModeMinusTwo = thisFurnace.iterationMode(3);
+            OperatingMode = furnace.iterationMode(1);
+            OperatingModeMinusOne = furnace.iterationMode(2);
+            OperatingModeMinusTwo = furnace.iterationMode(3);
             Oscillate = true;
             if (OperatingMode == OperatingModeMinusOne && OperatingMode == OperatingModeMinusTwo) Oscillate = false;
             if (Oscillate) {
@@ -5602,17 +4506,17 @@ namespace Furnaces {
         }
 
         // EMS override point
-        if (thisFurnace.EMSOverrideSensZoneLoadRequest) ZoneLoad = thisFurnace.EMSSensibleZoneLoadValue;
-        if (thisFurnace.EMSOverrideMoistZoneLoadRequest) MoistureLoad = thisFurnace.EMSMoistureZoneLoadValue;
-        if (thisFurnace.EMSOverrideSensZoneLoadRequest || thisFurnace.EMSOverrideMoistZoneLoadRequest) {
-            if ((ZoneLoad != 0.0) && (thisFurnace.EMSOverrideSensZoneLoadRequest)) {
+        if (furnace.EMSOverrideSensZoneLoadRequest) ZoneLoad = furnace.EMSSensibleZoneLoadValue;
+        if (furnace.EMSOverrideMoistZoneLoadRequest) MoistureLoad = furnace.EMSMoistureZoneLoadValue;
+        if (furnace.EMSOverrideSensZoneLoadRequest || furnace.EMSOverrideMoistZoneLoadRequest) {
+            if ((ZoneLoad != 0.0) && (furnace.EMSOverrideSensZoneLoadRequest)) {
                 PartLoadRatio = 1.0;
-            } else if ((MoistureLoad != 0.0) && (thisFurnace.EMSOverrideMoistZoneLoadRequest)) {
+            } else if ((MoistureLoad != 0.0) && (furnace.EMSOverrideMoistZoneLoadRequest)) {
                 PartLoadRatio = 1.0;
             } else {
                 PartLoadRatio = 0.0;
             }
-            if (thisFurnace.NumOfSpeedCooling > 0) {
+            if (furnace.NumOfSpeedCooling > 0) {
                 SetOnOffMassFlowRate(state, FurnaceNum, AirLoopNum, OnOffAirFlowRatio, fanOp, QZnReq, MoistureLoad, PartLoadRatio);
             } else {
                 // This line is suspicious - all other calls to SetOnOffMassFlowRate pass in QZnReq, not ZoneLoad
@@ -5651,9 +4555,10 @@ namespace Furnaces {
         // air flow rates. Use these flow rates during the Calc routines to set the average mass flow rates
         // based on PLR.
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
         // Check for heat only furnace
-        if (thisFurnace.type != HVAC::UnitarySysType::Furnace_HeatOnly && thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatOnly) {
+        if (furnace.type != HVAC::UnitarySysType::Furnace_HeatOnly &&
+            furnace.type != HVAC::UnitarySysType::Unitary_HeatOnly) {
 
             // Set the system mass flow rates
             if (fanOp == HVAC::FanOp::Continuous) {
@@ -5661,39 +4566,39 @@ namespace Furnaces {
                 // constant fan mode
                 if (state.dataFurnaces->HeatingLoad) {
                     //       IF a heating and moisture load exists, operate at the cooling mass flow rate ELSE operate at the heating flow rate
-                    if (MoistureLoad < 0.0 && thisFurnace.Humidistat &&
-                        thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.CoolingSpeedRatio;
+                    if (MoistureLoad < 0.0 && furnace.Humidistat &&
+                        furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+                        state.dataFurnaces->CompOnMassFlow = furnace.MaxCoolAirMassFlow;
+                        state.dataFurnaces->CompOnFlowRatio = furnace.CoolingSpeedRatio;
                     } else {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxHeatAirMassFlow;
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.HeatingSpeedRatio;
+                        state.dataFurnaces->CompOnMassFlow = furnace.MaxHeatAirMassFlow;
+                        state.dataFurnaces->CompOnFlowRatio = furnace.HeatingSpeedRatio;
                     }
-                    thisFurnace.LastMode = Furnaces::ModeOfOperation::HeatingMode;
+                    furnace.LastMode = Furnaces::ModeOfOperation::HeatingMode;
                     //     IF a cooling load exists, operate at the cooling mass flow rate
                 } else if (state.dataFurnaces->CoolingLoad) {
-                    state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                    state.dataFurnaces->CompOnFlowRatio = thisFurnace.CoolingSpeedRatio;
-                    thisFurnace.LastMode = Furnaces::ModeOfOperation::CoolingMode;
+                    state.dataFurnaces->CompOnMassFlow = furnace.MaxCoolAirMassFlow;
+                    state.dataFurnaces->CompOnFlowRatio = furnace.CoolingSpeedRatio;
+                    furnace.LastMode = Furnaces::ModeOfOperation::CoolingMode;
                     //     If no load exists, set the compressor on mass flow rate.
                     //     Set equal the mass flow rate when no heating or cooling is needed if no moisture load exists.
                     //     If the user has set the off mass flow rate to 0, set according to the last operating mode.
                 } else {
-                    if (MoistureLoad < 0.0 && thisFurnace.Humidistat &&
-                        thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.CoolingSpeedRatio;
+                    if (MoistureLoad < 0.0 && furnace.Humidistat &&
+                        furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+                        state.dataFurnaces->CompOnMassFlow = furnace.MaxCoolAirMassFlow;
+                        state.dataFurnaces->CompOnFlowRatio = furnace.CoolingSpeedRatio;
                     } else {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxNoCoolHeatAirMassFlow;
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.HeatingSpeedRatio;
+                        state.dataFurnaces->CompOnMassFlow = furnace.MaxNoCoolHeatAirMassFlow;
+                        state.dataFurnaces->CompOnFlowRatio = furnace.HeatingSpeedRatio;
                         //         User may have entered a 0 for MaxNoCoolHeatAirMassFlow
                         if (state.dataFurnaces->CompOnMassFlow == 0.0) {
-                            if (thisFurnace.LastMode == Furnaces::ModeOfOperation::HeatingMode) {
-                                state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxHeatAirMassFlow;
-                                state.dataFurnaces->CompOnFlowRatio = thisFurnace.HeatingSpeedRatio;
+                            if (furnace.LastMode == Furnaces::ModeOfOperation::HeatingMode) {
+                                state.dataFurnaces->CompOnMassFlow = furnace.MaxHeatAirMassFlow;
+                                state.dataFurnaces->CompOnFlowRatio = furnace.HeatingSpeedRatio;
                             } else {
-                                state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                                state.dataFurnaces->CompOnFlowRatio = thisFurnace.CoolingSpeedRatio;
+                                state.dataFurnaces->CompOnMassFlow = furnace.MaxCoolAirMassFlow;
+                                state.dataFurnaces->CompOnFlowRatio = furnace.CoolingSpeedRatio;
                             }
                         }
                     }
@@ -5701,43 +4606,43 @@ namespace Furnaces {
 
                 //     Set the compressor or coil OFF mass flow rate based on LOGICAL flag
                 //     UseCompressorOnFlow is used when the user does not enter a value for no cooling or heating flow rate
-                if (thisFurnace.AirFlowControl == AirFlowControlConstFan::UseCompressorOnFlow) {
-                    if (thisFurnace.LastMode == Furnaces::ModeOfOperation::HeatingMode) {
-                        if (MoistureLoad < 0.0 && thisFurnace.Humidistat &&
-                            thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
-                            state.dataFurnaces->CompOffMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                            state.dataFurnaces->CompOffFlowRatio = thisFurnace.CoolingSpeedRatio;
+                if (furnace.AirFlowControl == AirFlowControlConstFan::UseCompressorOnFlow) {
+                    if (furnace.LastMode == Furnaces::ModeOfOperation::HeatingMode) {
+                        if (MoistureLoad < 0.0 && furnace.Humidistat &&
+                            furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+                            state.dataFurnaces->CompOffMassFlow = furnace.MaxCoolAirMassFlow;
+                            state.dataFurnaces->CompOffFlowRatio = furnace.CoolingSpeedRatio;
                         } else {
-                            state.dataFurnaces->CompOffMassFlow = thisFurnace.MaxHeatAirMassFlow;
-                            state.dataFurnaces->CompOffFlowRatio = thisFurnace.HeatingSpeedRatio;
+                            state.dataFurnaces->CompOffMassFlow = furnace.MaxHeatAirMassFlow;
+                            state.dataFurnaces->CompOffFlowRatio = furnace.HeatingSpeedRatio;
                         }
                     } else {
-                        state.dataFurnaces->CompOffMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                        state.dataFurnaces->CompOffFlowRatio = thisFurnace.CoolingSpeedRatio;
+                        state.dataFurnaces->CompOffMassFlow = furnace.MaxCoolAirMassFlow;
+                        state.dataFurnaces->CompOffFlowRatio = furnace.CoolingSpeedRatio;
                     }
                     //     ELSE use the user specified value
                 } else {
-                    state.dataFurnaces->CompOffMassFlow = thisFurnace.MaxNoCoolHeatAirMassFlow;
-                    state.dataFurnaces->CompOffFlowRatio = thisFurnace.NoHeatCoolSpeedRatio;
+                    state.dataFurnaces->CompOffMassFlow = furnace.MaxNoCoolHeatAirMassFlow;
+                    state.dataFurnaces->CompOffFlowRatio = furnace.NoHeatCoolSpeedRatio;
                 }
             } else {
                 //     cycling fan mode
                 if (state.dataFurnaces->HeatingLoad ||
-                    (thisFurnace.Humidistat && MoistureLoad < 0.0 && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat)) {
+                    (furnace.Humidistat && MoistureLoad < 0.0 && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat)) {
 
-                    if (thisFurnace.Humidistat && MoistureLoad < 0.0 &&
-                        thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.CoolingSpeedRatio;
-                        thisFurnace.LastMode = Furnaces::ModeOfOperation::CoolingMode;
+                    if (furnace.Humidistat && MoistureLoad < 0.0 &&
+                        furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+                        state.dataFurnaces->CompOnMassFlow = furnace.MaxCoolAirMassFlow;
+                        state.dataFurnaces->CompOnFlowRatio = furnace.CoolingSpeedRatio;
+                        furnace.LastMode = Furnaces::ModeOfOperation::CoolingMode;
                     } else {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxHeatAirMassFlow;
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.HeatingSpeedRatio;
-                        thisFurnace.LastMode = Furnaces::ModeOfOperation::HeatingMode;
+                        state.dataFurnaces->CompOnMassFlow = furnace.MaxHeatAirMassFlow;
+                        state.dataFurnaces->CompOnFlowRatio = furnace.HeatingSpeedRatio;
+                        furnace.LastMode = Furnaces::ModeOfOperation::HeatingMode;
                     }
                 } else if (state.dataFurnaces->CoolingLoad) {
-                    state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                    state.dataFurnaces->CompOnFlowRatio = thisFurnace.CoolingSpeedRatio;
+                    state.dataFurnaces->CompOnMassFlow = furnace.MaxCoolAirMassFlow;
+                    state.dataFurnaces->CompOnFlowRatio = furnace.CoolingSpeedRatio;
                 } else {
                     state.dataFurnaces->CompOnMassFlow = 0.0;
                     state.dataFurnaces->CompOnFlowRatio = 0.0;
@@ -5747,11 +4652,11 @@ namespace Furnaces {
             }
         } else { //  Is a HeatOnly furnace
 
-            state.dataFurnaces->CompOnMassFlow = thisFurnace.DesignMassFlowRate;
-            state.dataFurnaces->CompOnFlowRatio = thisFurnace.HeatingSpeedRatio;
+            state.dataFurnaces->CompOnMassFlow = furnace.DesignMassFlowRate;
+            state.dataFurnaces->CompOnFlowRatio = furnace.HeatingSpeedRatio;
             if (fanOp == HVAC::FanOp::Continuous) {
-                state.dataFurnaces->CompOffMassFlow = thisFurnace.MaxNoCoolHeatAirMassFlow;
-                state.dataFurnaces->CompOffFlowRatio = thisFurnace.HeatingSpeedRatio;
+                state.dataFurnaces->CompOffMassFlow = furnace.MaxNoCoolHeatAirMassFlow;
+                state.dataFurnaces->CompOffFlowRatio = furnace.HeatingSpeedRatio;
             } else {
                 state.dataFurnaces->CompOffMassFlow = 0.0;
                 state.dataFurnaces->CompOffFlowRatio = 0.0;
@@ -5788,7 +4693,6 @@ namespace Furnaces {
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         int Iter;                 // iteration count
         Real64 MulSpeedFlowScale; // variable speed air flow scaling factor
-        int IHPCoilIndex;         // refer to cooling or heating coil in IHP
         Real64 dummy(0.0);
         bool anyRan;
         EMSManager::ManageEMS(state, EMSManager::EMSCallFrom::UnitarySystemSizing, anyRan, ObjexxFCL::Optional_int_const()); // calling point
@@ -5796,65 +4700,58 @@ namespace Furnaces {
         state.dataSize->DXCoolCap = 0.0;
         state.dataSize->UnitaryHeatCap = 0.0;
         state.dataSize->SuppHeatCap = 0.0;
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-
-        state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum = thisFurnace.FanIndex;
-        state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanType = thisFurnace.fanType;
-        state.dataSize->DataFanType = thisFurnace.fanType;
-        state.dataSize->DataFanIndex = thisFurnace.FanIndex;
-
-        state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace = thisFurnace.fanPlace;
-
-        if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-            DXCoils::SimDXCoil(state, BlankString, HVAC::CompressorOp::On, true, thisFurnace.CoolingCoilIndex, HVAC::FanOp::Cycling, 0.0);
-        } else if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-            int HXCC_Index = thisFurnace.CoolingCoilIndex;
-            int childCCType_Num = state.dataHVACAssistedCC->HXAssistedCoil(HXCC_Index).CoolingCoilType_Num;
-            if (childCCType_Num == HVAC::CoilDX_Cooling) {
-                int childCCIndex = state.dataHVACAssistedCC->HXAssistedCoil(HXCC_Index).CoolingCoilIndex;
-                if (childCCIndex < 0) {
-                    ShowContinueError(state, "Occurs in sizing HeatExchangerAssistedCoolingCoil.");
-                }
-                auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex];
-                newCoil.size(state);
-            }
-            HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
-                state, BlankString, true, HVAC::CompressorOp::On, 0.0, thisFurnace.CoolingCoilIndex, HVAC::FanOp::Cycling, false, 1.0, false);
-        } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+
+        state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum = furnace.FanIndex;
+        state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanType = furnace.fanType;
+        state.dataSize->DataFanType = furnace.fanType;
+        state.dataSize->DataFanIndex = furnace.FanIndex;
+
+        state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace = furnace.fanPlace;
+
+        if (furnace.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+            DXCoils::SimDXCoil(state, furnace.CoolCoilNum, HVAC::CompressorOp::On, true, HVAC::FanOp::Cycling, 0.0);
+            
+        } else if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+            if (furnace.childCoolCoilType == HVAC::CoilType::CoolingDX) {
+                state.dataCoilCoolingDX->coilCoolingDXs[furnace.childCoolCoilNum].size(state);
+            }
+            HXAssistCoil::SimHXAssistedCoolingCoil(
+                state, furnace.CoolCoilNum, true, HVAC::CompressorOp::On, 0.0, HVAC::FanOp::Cycling, false, 1.0, false);
+
+        } else if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
             WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                            BlankString,
-                                                            thisFurnace.CoolingCoilIndex,
-                                                            thisFurnace.CoolingCoilSensDemand,
-                                                            thisFurnace.CoolingCoilLatentDemand,
+                                                            furnace.CoolCoilNum,
+                                                            furnace.CoolingCoilSensDemand,
+                                                            furnace.CoolingCoilLatentDemand,
                                                             HVAC::FanOp::Invalid, // Using invalid to mean off?
                                                             HVAC::CompressorOp::Off,
                                                             0.0,
                                                             FirstHVACIteration); // CoolPartLoadRatio
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple) {
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                BlankString,
-                                                                thisFurnace.HeatingCoilIndex,
-                                                                thisFurnace.HeatingCoilSensDemand,
+                                                                furnace.HeatCoilNum,
+                                                                furnace.HeatingCoilSensDemand,
                                                                 dummy,
                                                                 HVAC::FanOp::Invalid, // using Invalid to mean off?
                                                                 HVAC::CompressorOp::Off,
                                                                 0.0,
                                                                 FirstHVACIteration);
             }
-        } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-                   thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            if (thisFurnace.bIsIHP) {
-                IntegratedHeatPump::SizeIHP(state, thisFurnace.CoolingCoilIndex);
-                IHPCoilIndex = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SCCoilIndex;
-                thisFurnace.NumOfSpeedCooling = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).NumOfSpeeds;
-                MulSpeedFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).RatedAirVolFlowRate /
-                                    state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex)
-                                        .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).NormSpedLevel);
-                state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).CoolVolFlowScale = MulSpeedFlowScale;
+            
+        } else if (furnace.coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+                   furnace.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            auto const &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.CoolCoilNum);
+            furnace.NumOfSpeedCooling = vsCoil.NumOfSpeeds;
+            
+            if (furnace.isIHP) {
+                IntegratedHeatPump::SizeIHP(state, furnace.ihpNum);
+                MulSpeedFlowScale = vsCoil.RatedAirVolFlowRate / vsCoil.MSRatedAirVolFlowRate(vsCoil.NormSpedLevel);
+                state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).CoolVolFlowScale = MulSpeedFlowScale;
             } else {
                 VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                           BlankString,
-                                                          thisFurnace.CoolingCoilIndex,
+                                                          furnace.CoolCoilNum,
                                                           HVAC::FanOp::Invalid, // USing Invalid for off?
                                                           HVAC::CompressorOp::Off,
                                                           0.0,
@@ -5863,39 +4760,32 @@ namespace Furnaces {
                                                           0.0,
                                                           0.0,
                                                           0.0); // conduct the sizing operation in the VS WSHP
-                thisFurnace.NumOfSpeedCooling = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.CoolingCoilIndex).NumOfSpeeds;
-                MulSpeedFlowScale =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.CoolingCoilIndex).RatedAirVolFlowRate /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.CoolingCoilIndex)
-                        .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.CoolingCoilIndex).NormSpedLevel);
-                IHPCoilIndex = thisFurnace.CoolingCoilIndex;
-            }
-
-            for (Iter = 1; Iter <= thisFurnace.NumOfSpeedCooling; ++Iter) {
-                thisFurnace.CoolVolumeFlowRate(Iter) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirVolFlowRate(Iter) * MulSpeedFlowScale;
-                thisFurnace.CoolMassFlowRate(Iter) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirMassFlowRate(Iter) * MulSpeedFlowScale;
-                thisFurnace.MSCoolingSpeedRatio(Iter) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirVolFlowRate(Iter) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirVolFlowRate(thisFurnace.NumOfSpeedCooling);
-            }
-
-            if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-
-                if (thisFurnace.bIsIHP) {
-                    IntegratedHeatPump::SizeIHP(state, thisFurnace.CoolingCoilIndex);
-                    IHPCoilIndex = state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).SHCoilIndex;
-                    thisFurnace.NumOfSpeedHeating = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).NumOfSpeeds;
-                    MulSpeedFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).RatedAirVolFlowRate /
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex)
-                                            .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).NormSpedLevel);
-                    state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).HeatVolFlowScale = MulSpeedFlowScale;
+                MulSpeedFlowScale = vsCoil.RatedAirVolFlowRate / vsCoil.MSRatedAirVolFlowRate(vsCoil.NormSpedLevel);
+            }
+
+            for (Iter = 1; Iter <= furnace.NumOfSpeedCooling; ++Iter) {
+                furnace.CoolVolumeFlowRate(Iter) = vsCoil.MSRatedAirVolFlowRate(Iter) * MulSpeedFlowScale;
+                furnace.CoolMassFlowRate(Iter) = vsCoil.MSRatedAirMassFlowRate(Iter) * MulSpeedFlowScale;
+                furnace.MSCoolingSpeedRatio(Iter) = vsCoil.MSRatedAirVolFlowRate(Iter) / vsCoil.MSRatedAirVolFlowRate(furnace.NumOfSpeedCooling);
+            }
+
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+                furnace.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+
+                // In the case of IHP, HeatCoilNum is the index of
+                // the Coil in the IHP.  IHP index is the index of the
+                // IHP object.
+                auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.HeatCoilNum);
+                furnace.NumOfSpeedHeating = vsCoil.NumOfSpeeds;
+                
+                if (furnace.isIHP) {
+                    IntegratedHeatPump::SizeIHP(state, furnace.ihpNum);
+                    MulSpeedFlowScale = vsCoil.RatedAirVolFlowRate / vsCoil.MSRatedAirVolFlowRate(vsCoil.NormSpedLevel);
+                    state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).HeatVolFlowScale = MulSpeedFlowScale;
                 } else {
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                               BlankString,
-                                                              thisFurnace.HeatingCoilIndex,
+                                                              furnace.HeatCoilNum,
                                                               HVAC::FanOp::Invalid, // Invalid for off?
                                                               HVAC::CompressorOp::Off,
                                                               0.0,
@@ -5904,237 +4794,228 @@ namespace Furnaces {
                                                               0.0,
                                                               0.0,
                                                               0.0); // conduct the sizing operation in the VS WSHP
-                    thisFurnace.NumOfSpeedHeating = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.HeatingCoilIndex).NumOfSpeeds;
-                    MulSpeedFlowScale =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.HeatingCoilIndex).RatedAirVolFlowRate /
-                        state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.HeatingCoilIndex)
-                            .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.HeatingCoilIndex).NormSpedLevel);
-                    IHPCoilIndex = thisFurnace.HeatingCoilIndex;
+                    MulSpeedFlowScale = vsCoil.RatedAirVolFlowRate / vsCoil.MSRatedAirVolFlowRate(vsCoil.NormSpedLevel);
                 }
 
-                for (Iter = 1; Iter <= thisFurnace.NumOfSpeedHeating; ++Iter) {
-                    thisFurnace.HeatVolumeFlowRate(Iter) =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirVolFlowRate(Iter) * MulSpeedFlowScale;
-                    thisFurnace.HeatMassFlowRate(Iter) =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirMassFlowRate(Iter) * MulSpeedFlowScale;
-                    thisFurnace.MSHeatingSpeedRatio(Iter) =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirVolFlowRate(Iter) /
-                        state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedAirVolFlowRate(thisFurnace.NumOfSpeedHeating);
+                for (Iter = 1; Iter <= furnace.NumOfSpeedHeating; ++Iter) {
+                    furnace.HeatVolumeFlowRate(Iter) = vsCoil.MSRatedAirVolFlowRate(Iter) * MulSpeedFlowScale;
+                    furnace.HeatMassFlowRate(Iter) = vsCoil.MSRatedAirMassFlowRate(Iter) * MulSpeedFlowScale;
+                    furnace.MSHeatingSpeedRatio(Iter) = vsCoil.MSRatedAirVolFlowRate(Iter) / vsCoil.MSRatedAirVolFlowRate(furnace.NumOfSpeedHeating);
                 }
             }
 
-            if (thisFurnace.NumOfSpeedHeating > 0) {
-                thisFurnace.IdleMassFlowRate = min(thisFurnace.HeatMassFlowRate(1), thisFurnace.CoolMassFlowRate(1));
-                thisFurnace.IdleSpeedRatio = min(thisFurnace.MSHeatingSpeedRatio(1), thisFurnace.MSCoolingSpeedRatio(1));
-                thisFurnace.IdleVolumeAirRate = min(thisFurnace.HeatVolumeFlowRate(1), thisFurnace.CoolVolumeFlowRate(1));
+            if (furnace.NumOfSpeedHeating > 0) {
+                furnace.IdleMassFlowRate = min(furnace.HeatMassFlowRate(1), furnace.CoolMassFlowRate(1));
+                furnace.IdleSpeedRatio = min(furnace.MSHeatingSpeedRatio(1), furnace.MSCoolingSpeedRatio(1));
+                furnace.IdleVolumeAirRate = min(furnace.HeatVolumeFlowRate(1), furnace.CoolVolumeFlowRate(1));
             } else {
-                thisFurnace.IdleMassFlowRate = thisFurnace.CoolMassFlowRate(1);
-                thisFurnace.IdleSpeedRatio = thisFurnace.MSCoolingSpeedRatio(1);
-                thisFurnace.IdleVolumeAirRate = thisFurnace.CoolVolumeFlowRate(1);
+                furnace.IdleMassFlowRate = furnace.CoolMassFlowRate(1);
+                furnace.IdleSpeedRatio = furnace.MSCoolingSpeedRatio(1);
+                furnace.IdleVolumeAirRate = furnace.CoolVolumeFlowRate(1);
             }
 
-            if (thisFurnace.fanOp == HVAC::FanOp::Continuous) {
-                thisFurnace.MaxNoCoolHeatAirVolFlow = thisFurnace.IdleVolumeAirRate;
-                thisFurnace.MaxNoCoolHeatAirMassFlow = thisFurnace.IdleMassFlowRate;
-                thisFurnace.NoHeatCoolSpeedRatio = thisFurnace.IdleSpeedRatio;
+            if (furnace.fanOp == HVAC::FanOp::Continuous) {
+                furnace.MaxNoCoolHeatAirVolFlow = furnace.IdleVolumeAirRate;
+                furnace.MaxNoCoolHeatAirMassFlow = furnace.IdleMassFlowRate;
+                furnace.NoHeatCoolSpeedRatio = furnace.IdleSpeedRatio;
             }
         }
 
-        if (thisFurnace.DesignFanVolFlowRate == DataSizing::AutoSize) {
+        if (furnace.DesignFanVolFlowRate == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
+                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
                 if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
-                    thisFurnace.DesignFanVolFlowRate = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
+                    furnace.DesignFanVolFlowRate = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
                 } else {
-                    thisFurnace.DesignFanVolFlowRate = 0.0;
+                    furnace.DesignFanVolFlowRate = 0.0;
                 }
 
-                if (thisFurnace.DesignFanVolFlowRateEMSOverrideOn) {
-                    thisFurnace.DesignFanVolFlowRate = thisFurnace.DesignFanVolFlowRateEMSOverrideValue;
+                if (furnace.DesignFanVolFlowRateEMSOverrideOn) {
+                    furnace.DesignFanVolFlowRate = furnace.DesignFanVolFlowRateEMSOverrideValue;
                 }
 
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Supply Air Flow Rate [m3/s]",
-                                             thisFurnace.DesignFanVolFlowRate);
+                                             furnace.DesignFanVolFlowRate);
             }
         }
 
-        if (thisFurnace.MaxHeatAirVolFlow == DataSizing::AutoSize) {
+        if (furnace.MaxHeatAirVolFlow == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
+                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
                 if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
-                    thisFurnace.MaxHeatAirVolFlow = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
+                    furnace.MaxHeatAirVolFlow = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
                 } else {
-                    thisFurnace.MaxHeatAirVolFlow = 0.0;
+                    furnace.MaxHeatAirVolFlow = 0.0;
                 }
 
-                if (thisFurnace.MaxHeatAirVolFlowEMSOverrideOn) {
-                    thisFurnace.MaxHeatAirVolFlow = thisFurnace.MaxHeatAirVolFlowEMSOverrideValue;
+                if (furnace.MaxHeatAirVolFlowEMSOverrideOn) {
+                    furnace.MaxHeatAirVolFlow = furnace.MaxHeatAirVolFlowEMSOverrideValue;
                 }
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Supply Air Flow Rate During Heating Operation [m3/s]",
-                                             thisFurnace.MaxHeatAirVolFlow);
+                                             furnace.MaxHeatAirVolFlow);
             }
         }
 
-        if (thisFurnace.MaxCoolAirVolFlow == DataSizing::AutoSize) {
+        if (furnace.MaxCoolAirVolFlow == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
+                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
                 if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
-                    thisFurnace.MaxCoolAirVolFlow = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
+                    furnace.MaxCoolAirVolFlow = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
                 } else {
-                    thisFurnace.MaxCoolAirVolFlow = 0.0;
+                    furnace.MaxCoolAirVolFlow = 0.0;
                 }
 
-                if (thisFurnace.MaxCoolAirVolFlowEMSOverrideOn) {
-                    thisFurnace.MaxCoolAirVolFlow = thisFurnace.MaxCoolAirVolFlowEMSOverrideValue;
+                if (furnace.MaxCoolAirVolFlowEMSOverrideOn) {
+                    furnace.MaxCoolAirVolFlow = furnace.MaxCoolAirVolFlowEMSOverrideValue;
                 }
 
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Supply Air Flow Rate During Cooling Operation [m3/s]",
-                                             thisFurnace.MaxCoolAirVolFlow);
+                                             furnace.MaxCoolAirVolFlow);
             }
         }
 
-        if (thisFurnace.MaxNoCoolHeatAirVolFlow == DataSizing::AutoSize) {
+        if (furnace.MaxNoCoolHeatAirVolFlow == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
+                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
                 if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
-                    thisFurnace.MaxNoCoolHeatAirVolFlow = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
+                    furnace.MaxNoCoolHeatAirVolFlow = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
                 } else {
-                    thisFurnace.MaxNoCoolHeatAirVolFlow = 0.0;
+                    furnace.MaxNoCoolHeatAirVolFlow = 0.0;
                 }
 
-                if (thisFurnace.MaxNoCoolHeatAirVolFlowEMSOverrideOn) {
-                    thisFurnace.MaxNoCoolHeatAirVolFlow = thisFurnace.MaxNoCoolHeatAirVolFlowEMSOverrideValue;
+                if (furnace.MaxNoCoolHeatAirVolFlowEMSOverrideOn) {
+                    furnace.MaxNoCoolHeatAirVolFlow = furnace.MaxNoCoolHeatAirVolFlowEMSOverrideValue;
                 }
 
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Supply Air Flow Rate When No Cooling or Heating is Needed [m3/s]",
-                                             thisFurnace.MaxNoCoolHeatAirVolFlow);
+                                             furnace.MaxNoCoolHeatAirVolFlow);
             }
         }
 
-        if (thisFurnace.DesignHeatingCapacity == DataSizing::AutoSize) {
+        if (furnace.DesignHeatingCapacity == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                    thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+                if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                    furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
 
-                    CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
+                    CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
 
-                    if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple) {
-                        thisFurnace.DesignHeatingCapacity =
-                            state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(thisFurnace.HeatingCoilIndex).RatedCapHeat;
+                    if (furnace.heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
+                        furnace.DesignHeatingCapacity =
+                            state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(furnace.HeatCoilNum).RatedCapHeat;
                     } else {
-                        thisFurnace.DesignHeatingCapacity = state.dataSize->DXCoolCap;
+                        furnace.DesignHeatingCapacity = state.dataSize->DXCoolCap;
                     }
 
                 } else {
 
-                    CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
+                    CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
 
-                    thisFurnace.DesignHeatingCapacity = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatCap;
+                    furnace.DesignHeatingCapacity = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatCap;
                 }
 
-                if (thisFurnace.DesignHeatingCapacity < HVAC::SmallLoad) {
-                    thisFurnace.DesignHeatingCapacity = 0.0;
+                if (furnace.DesignHeatingCapacity < HVAC::SmallLoad) {
+                    furnace.DesignHeatingCapacity = 0.0;
                 }
 
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Nominal Heating Capacity [W]",
-                                             thisFurnace.DesignHeatingCapacity);
+                                             furnace.DesignHeatingCapacity);
             }
         }
 
-        if (thisFurnace.DesignCoolingCapacity == DataSizing::AutoSize) {
+        if (furnace.DesignCoolingCapacity == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
+                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
                 if (state.dataSize->DXCoolCap >= HVAC::SmallLoad) {
-                    thisFurnace.DesignCoolingCapacity = state.dataSize->DXCoolCap;
+                    furnace.DesignCoolingCapacity = state.dataSize->DXCoolCap;
                 } else {
-                    thisFurnace.DesignCoolingCapacity = 0.0;
+                    furnace.DesignCoolingCapacity = 0.0;
                 }
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Nominal Cooling Capacity [W]",
-                                             thisFurnace.DesignCoolingCapacity);
+                                             furnace.DesignCoolingCapacity);
             }
         }
 
-        if (thisFurnace.DesignMaxOutletTemp == DataSizing::AutoSize) {
+        if (furnace.DesignMaxOutletTemp == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
-                thisFurnace.DesignMaxOutletTemp = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatSupTemp;
+                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
+                furnace.DesignMaxOutletTemp = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatSupTemp;
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Maximum Supply Air Temperature from Supplemental Heater [C]",
-                                             thisFurnace.DesignMaxOutletTemp);
+                                             furnace.DesignMaxOutletTemp);
             }
         }
 
-        if (thisFurnace.DesignSuppHeatingCapacity == DataSizing::AutoSize) {
+        if (furnace.DesignSuppHeatingCapacity == DataSizing::AutoSize) {
 
             if (state.dataSize->CurSysNum > 0) {
 
-                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name);
-                if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                    thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+                CheckSysSizing(state, HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name);
+                if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                    furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
                     // set the supplemental heating capacity to the actual heating load
-                    thisFurnace.DesignSuppHeatingCapacity = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatCap;
+                    furnace.DesignSuppHeatingCapacity = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatCap;
                     // if reheat needed for humidity control, make sure supplemental heating is at least as big
                     // as the cooling capacity
-                    if (thisFurnace.Humidistat && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
-                        thisFurnace.DesignSuppHeatingCapacity = max(thisFurnace.DesignSuppHeatingCapacity, thisFurnace.DesignCoolingCapacity);
-                        if (thisFurnace.DesignSuppHeatingCapacity < HVAC::SmallLoad) {
-                            thisFurnace.DesignSuppHeatingCapacity = 0.0;
+                    if (furnace.Humidistat && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+                        furnace.DesignSuppHeatingCapacity = max(furnace.DesignSuppHeatingCapacity, furnace.DesignCoolingCapacity);
+                        if (furnace.DesignSuppHeatingCapacity < HVAC::SmallLoad) {
+                            furnace.DesignSuppHeatingCapacity = 0.0;
                         }
                     }
 
                 } else {
 
-                    if (thisFurnace.Humidistat && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
-                        thisFurnace.DesignSuppHeatingCapacity = thisFurnace.DesignCoolingCapacity;
+                    if (furnace.Humidistat && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+                        furnace.DesignSuppHeatingCapacity = furnace.DesignCoolingCapacity;
                     } else {
-                        thisFurnace.DesignSuppHeatingCapacity = 0.0;
+                        furnace.DesignSuppHeatingCapacity = 0.0;
                     }
                 }
 
                 BaseSizer::reportSizerOutput(state,
-                                             HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                             thisFurnace.Name,
+                                             HVAC::unitarySysTypeNames[(int)furnace.type],
+                                             furnace.Name,
                                              "Supplemental Heating Coil Nominal Capacity [W]",
-                                             thisFurnace.DesignSuppHeatingCapacity);
+                                             furnace.DesignSuppHeatingCapacity);
             }
         }
 
-        state.dataSize->UnitaryHeatCap = thisFurnace.DesignHeatingCapacity;
-        state.dataSize->SuppHeatCap = thisFurnace.DesignSuppHeatingCapacity;
+        state.dataSize->UnitaryHeatCap = furnace.DesignHeatingCapacity;
+        state.dataSize->SuppHeatCap = furnace.DesignSuppHeatingCapacity;
     }
 
     // End Initialization Section of the Module
@@ -6181,14 +5062,14 @@ namespace Furnaces {
         Real64 ActualLatentOutput;   // Actual furnace latent capacity = 0
         Real64 deltaT;               // Heater outlet temp minus design heater outlet temp
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
         // Retrieve the load on the controlled zone
-        auto &furnaceInNode = state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum);
-        auto const &furnaceOutNode = state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum);
-        int ControlZoneNode = thisFurnace.NodeNumOfControlledZone;
-        HVAC::FanOp fanOp = thisFurnace.fanOp; // fan operating mode
-        thisFurnace.MdotFurnace = thisFurnace.DesignMassFlowRate;
-        thisFurnace.CoolPartLoadRatio = 0.0;
+        auto &furnaceInNode = state.dataLoopNodes->Node(furnace.FurnaceInletNode);
+        auto const &furnaceOutNode = state.dataLoopNodes->Node(furnace.FurnaceOutletNode);
+        int ControlZoneNode = furnace.NodeNumOfControlledZone;
+        HVAC::FanOp fanOp = furnace.fanOp; // fan operating mode
+        furnace.MdotFurnace = furnace.DesignMassFlowRate;
+        furnace.CoolPartLoadRatio = 0.0;
 
         // Calculate the Cp Air of zone
         Real64 cpair = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(ControlZoneNode).HumRat);
@@ -6198,10 +5079,10 @@ namespace Furnaces {
             state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
         } else {
             // If Furnace runs then set HeatCoilLoad on Heating Coil and the Mass Flow
-            if ((thisFurnace.availSched->getCurrentVal() > 0.0) && (furnaceInNode.MassFlowRate > 0.0) && (state.dataFurnaces->HeatingLoad)) {
+            if ((furnace.availSched->getCurrentVal() > 0.0) && (furnaceInNode.MassFlowRate > 0.0) && (state.dataFurnaces->HeatingLoad)) {
 
-                furnaceInNode.MassFlowRate = thisFurnace.MdotFurnace;
-                HeatCoilLoad = thisFurnace.DesignHeatingCapacity;
+                furnaceInNode.MassFlowRate = furnace.MdotFurnace;
+                HeatCoilLoad = furnace.DesignHeatingCapacity;
                 SystemSensibleLoad = ZoneLoad;
 
                 // Get no load result
@@ -6230,7 +5111,7 @@ namespace Furnaces {
                                   OnOffAirFlowRatio,
                                   false);
 
-                furnaceInNode.MassFlowRate = thisFurnace.MdotFurnace;
+                furnaceInNode.MassFlowRate = furnace.MdotFurnace;
 
                 // Set fan part-load fraction equal to 1 while getting full load result
                 state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
@@ -6258,12 +5139,12 @@ namespace Furnaces {
                     PartLoadRatio =
                         max(MinPLR, min(1.0, std::abs(SystemSensibleLoad - NoSensibleOutput) / std::abs(FullSensibleOutput - NoSensibleOutput)));
                     if (fanOp == HVAC::FanOp::Cycling) {
-                        furnaceInNode.MassFlowRate = thisFurnace.MdotFurnace * PartLoadRatio;
-                        HeatCoilLoad = thisFurnace.DesignHeatingCapacity * PartLoadRatio;
+                        furnaceInNode.MassFlowRate = furnace.MdotFurnace * PartLoadRatio;
+                        HeatCoilLoad = furnace.DesignHeatingCapacity * PartLoadRatio;
                     } else { // FanOp::Continuous
-                        if (furnaceOutNode.Temp > thisFurnace.DesignMaxOutletTemp) {
-                            deltaT = furnaceOutNode.Temp - thisFurnace.DesignMaxOutletTemp;
-                            if (HeatCoilLoad > thisFurnace.DesignHeatingCapacity) HeatCoilLoad = thisFurnace.DesignHeatingCapacity;
+                        if (furnaceOutNode.Temp > furnace.DesignMaxOutletTemp) {
+                            deltaT = furnaceOutNode.Temp - furnace.DesignMaxOutletTemp;
+                            if (HeatCoilLoad > furnace.DesignHeatingCapacity) HeatCoilLoad = furnace.DesignHeatingCapacity;
                             HeatCoilLoad -= furnaceInNode.MassFlowRate * cpair * deltaT;
                         } else {
                             HeatCoilLoad = SystemSensibleLoad - NoSensibleOutput;
@@ -6271,13 +5152,13 @@ namespace Furnaces {
                     }
 
                     // Calculate the part load ratio through iteration
-                    HeatErrorToler = thisFurnace.HeatingConvergenceTolerance; // Error tolerance for convergence from input deck
+                    HeatErrorToler = furnace.HeatingConvergenceTolerance; // Error tolerance for convergence from input deck
                     Error = 1.0;                                              // initialize error value for comparison against tolerance
                     state.dataFurnaces->Iter = 0;                             // initialize iteration counter
                     IterRelax = 0.9;                                          // relaxation factor for iterations
                     while (state.dataFurnaces->Iter <= MaxIter) {
 
-                        if (fanOp == HVAC::FanOp::Cycling) furnaceInNode.MassFlowRate = thisFurnace.MdotFurnace * PartLoadRatio;
+                        if (fanOp == HVAC::FanOp::Cycling) furnaceInNode.MassFlowRate = furnace.MdotFurnace * PartLoadRatio;
                         CalcFurnaceOutput(state,
                                           FurnaceNum,
                                           FirstHVACIteration,
@@ -6300,9 +5181,9 @@ namespace Furnaces {
                                 PartLoadRatio + IterRelax * (SystemSensibleLoad - ActualSensibleOutput) / (FullSensibleOutput - NoSensibleOutput)));
 
                         // limit the heating coil outlet air temperature to DesignMaxOutletTemp
-                        if (furnaceOutNode.Temp > thisFurnace.DesignMaxOutletTemp) {
-                            deltaT = furnaceOutNode.Temp - thisFurnace.DesignMaxOutletTemp;
-                            if (HeatCoilLoad > thisFurnace.DesignHeatingCapacity) HeatCoilLoad = thisFurnace.DesignHeatingCapacity;
+                        if (furnaceOutNode.Temp > furnace.DesignMaxOutletTemp) {
+                            deltaT = furnaceOutNode.Temp - furnace.DesignMaxOutletTemp;
+                            if (HeatCoilLoad > furnace.DesignHeatingCapacity) HeatCoilLoad = furnace.DesignHeatingCapacity;
                             HeatCoilLoad -= furnaceInNode.MassFlowRate * cpair * deltaT;
                             CalcFurnaceOutput(state,
                                               FurnaceNum,
@@ -6324,7 +5205,7 @@ namespace Furnaces {
                                                     PartLoadRatio + IterRelax * (SystemSensibleLoad - ActualSensibleOutput) /
                                                                         (FullSensibleOutput - NoSensibleOutput)));
                         } else {
-                            HeatCoilLoad = thisFurnace.DesignHeatingCapacity * PartLoadRatio;
+                            HeatCoilLoad = furnace.DesignHeatingCapacity * PartLoadRatio;
                         }
 
                         if (PartLoadRatio == MinPLR) break;
@@ -6335,44 +5216,44 @@ namespace Furnaces {
                     }
 
                     if (state.dataFurnaces->Iter > MaxIter) {
-                        if (thisFurnace.HeatingMaxIterIndex2 == 0) {
+                        if (furnace.HeatingMaxIterIndex2 == 0) {
                             ShowWarningMessage(state,
                                                format("{} \"{}\" -- Exceeded max heating iterations ({}) while adjusting furnace runtime.",
-                                                      HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                      thisFurnace.Name,
+                                                      HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                      furnace.Name,
                                                       MaxIter));
                             ShowContinueErrorTimeStamp(state, "");
                         }
                         ShowRecurringWarningErrorAtEnd(state,
                                                        format("{} \"{}\" -- Exceeded max heating iterations error continues...",
-                                                              HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                              thisFurnace.Name),
-                                                       thisFurnace.HeatingMaxIterIndex2);
+                                                              HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                              furnace.Name),
+                                                       furnace.HeatingMaxIterIndex2);
                     }
 
                 } else { // ELSE from IF(FullSensibleOutput.GT.NoSensibleOutput)THEN above
                     // Set part load ratio to 1 and run heater at design heating capacity
                     PartLoadRatio = 1.0;
-                    HeatCoilLoad = thisFurnace.DesignHeatingCapacity;
+                    HeatCoilLoad = furnace.DesignHeatingCapacity;
                 }
                 // Set the final results
                 //      IF (fanOp .EQ. FanOp::Cycling) THEN
                 //        Furnace(FurnaceNum)%MdotFurnace = Furnace(FurnaceNum)%MdotFurnace * PartLoadRatio
                 //      END IF
-                thisFurnace.MdotFurnace = furnaceInNode.MassFlowRate;
+                furnace.MdotFurnace = furnaceInNode.MassFlowRate;
 
-            } else if ((thisFurnace.availSched->getCurrentVal() > 0.0) && (furnaceInNode.MassFlowRate > 0.0) && (fanOp == HVAC::FanOp::Continuous)) {
+            } else if ((furnace.availSched->getCurrentVal() > 0.0) && (furnaceInNode.MassFlowRate > 0.0) && (fanOp == HVAC::FanOp::Continuous)) {
                 HeatCoilLoad = 0.0;
             } else { // no heating and no flow
-                thisFurnace.MdotFurnace = 0.0;
+                furnace.MdotFurnace = 0.0;
                 HeatCoilLoad = 0.0;
             } // End of the Scheduled Furnace If block
 
         } // End of the FirstHVACIteration control of the mass flow If block
 
         // Set the fan inlet node flow rates
-        furnaceInNode.MassFlowRateMaxAvail = thisFurnace.MdotFurnace;
-        furnaceInNode.MassFlowRate = thisFurnace.MdotFurnace;
+        furnaceInNode.MassFlowRateMaxAvail = furnace.MdotFurnace;
+        furnaceInNode.MassFlowRate = furnace.MdotFurnace;
     }
 
     void CalcNewZoneHeatCoolFlowRates(EnergyPlusData &state,
@@ -6471,12 +5352,12 @@ namespace Furnaces {
         Real64 OutdoorDryBulbTemp; // secondary coil (condenser) entering dry bulb temperature
 
         Real64 &SystemSensibleLoad = state.dataFurnaces->SystemSensibleLoad;
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
         // Set local variables
-        int FurnaceOutletNode = thisFurnace.FurnaceOutletNodeNum;
-        int FurnaceInletNode = thisFurnace.FurnaceInletNodeNum;
-        int ControlZoneNode = thisFurnace.NodeNumOfControlledZone;
-        HVAC::FanOp fanOp = thisFurnace.fanOp; // fan operating mode
+        int FurnaceOutletNode = furnace.FurnaceOutletNode;
+        int FurnaceInletNode = furnace.FurnaceInletNode;
+        int ControlZoneNode = furnace.NodeNumOfControlledZone;
+        HVAC::FanOp fanOp = furnace.fanOp; // fan operating mode
         bool HumControl = false;
         // Calculate the Cp Air of zone
         Real64 cpair = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(ControlZoneNode).HumRat);
@@ -6487,17 +5368,17 @@ namespace Furnaces {
         ReheatCoilLoad = 0.0;
         PartLoadRatio = 0.0;
 
-        if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
-            if (state.dataDXCoils->DXCoil(thisFurnace.HeatingCoilIndex)
+        if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
+            if (state.dataDXCoils->DXCoil(furnace.HeatCoilNum)
                     .IsSecondaryDXCoilInZone) { // assumes compressor is in same location as secondary coil
                 OutdoorDryBulbTemp =
-                    state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataDXCoils->DXCoil(thisFurnace.HeatingCoilIndex).SecZonePtr).ZT;
-            } else if (state.dataDXCoils->DXCoil(thisFurnace.CoolingCoilIndex).IsSecondaryDXCoilInZone) {
+                    state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataDXCoils->DXCoil(furnace.HeatCoilNum).SecZonePtr).ZT;
+            } else if (state.dataDXCoils->DXCoil(furnace.CoolCoilNum).IsSecondaryDXCoilInZone) {
                 OutdoorDryBulbTemp =
-                    state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataDXCoils->DXCoil(thisFurnace.CoolingCoilIndex).SecZonePtr).ZT;
+                    state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataDXCoils->DXCoil(furnace.CoolCoilNum).SecZonePtr).ZT;
             } else {
-                if (thisFurnace.CondenserNodeNum > 0) {
-                    OutdoorDryBulbTemp = state.dataLoopNodes->Node(thisFurnace.CondenserNodeNum).Temp;
+                if (furnace.CondenserNodeNum > 0) {
+                    OutdoorDryBulbTemp = state.dataLoopNodes->Node(furnace.CondenserNodeNum).Temp;
                 } else {
                     OutdoorDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
                 }
@@ -6510,44 +5391,44 @@ namespace Furnaces {
 
             // Init for heating
             if (state.dataFurnaces->HeatingLoad) {
-                if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                    (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && thisFurnace.WatertoAirHPType == WAHPCoilType::Simple)) {
-                    thisFurnace.HeatPartLoadRatio = 1.0;
+                if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                    (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && furnace.WatertoAirHPType == WAHPCoilType::Simple)) {
+                    furnace.HeatPartLoadRatio = 1.0;
                     HeatCoilLoad = 0.0;
-                    thisFurnace.HeatingCoilSensDemand = 0.0;
-                    thisFurnace.CoolingCoilSensDemand = 0.0;
-                    thisFurnace.CoolingCoilLatentDemand = 0.0;
+                    furnace.HeatingCoilSensDemand = 0.0;
+                    furnace.CoolingCoilSensDemand = 0.0;
+                    furnace.CoolingCoilLatentDemand = 0.0;
                 } else { // for furnaces
-                    thisFurnace.HeatPartLoadRatio = 0.0;
+                    furnace.HeatPartLoadRatio = 0.0;
                     HeatCoilLoad = ZoneLoad;
-                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
-                    thisFurnace.HeatingCoilSensDemand = 0.0;
-                    thisFurnace.CoolingCoilSensDemand = 0.0;
-                    thisFurnace.CoolingCoilLatentDemand = 0.0;
+                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
+                    furnace.HeatingCoilSensDemand = 0.0;
+                    furnace.CoolingCoilSensDemand = 0.0;
+                    furnace.CoolingCoilLatentDemand = 0.0;
                 }
                 ReheatCoilLoad = 0.0;
-                thisFurnace.CoolPartLoadRatio = 0.0;
+                furnace.CoolPartLoadRatio = 0.0;
 
                 // Init for cooling
             } else if (state.dataFurnaces->CoolingLoad) {
                 // air to air heat pumps
-                thisFurnace.CoolPartLoadRatio = 1.0;
-                thisFurnace.HeatPartLoadRatio = 0.0;
+                furnace.CoolPartLoadRatio = 1.0;
+                furnace.HeatPartLoadRatio = 0.0;
                 HeatCoilLoad = 0.0;
                 ReheatCoilLoad = 0.0;
 
                 // Init for moisture load only
             } else {
-                thisFurnace.CoolPartLoadRatio = 0.0;
-                thisFurnace.HeatPartLoadRatio = 0.0;
+                furnace.CoolPartLoadRatio = 0.0;
+                furnace.HeatPartLoadRatio = 0.0;
                 HeatCoilLoad = 0.0;
                 ReheatCoilLoad = 0.0;
-                thisFurnace.HeatingCoilSensDemand = 0.0;
-                thisFurnace.CoolingCoilSensDemand = 0.0;
-                thisFurnace.CoolingCoilLatentDemand = 0.0;
+                furnace.HeatingCoilSensDemand = 0.0;
+                furnace.CoolingCoilSensDemand = 0.0;
+                furnace.CoolingCoilLatentDemand = 0.0;
             }
 
-            SetAverageAirFlow(state, FurnaceNum, max(thisFurnace.HeatPartLoadRatio, thisFurnace.CoolPartLoadRatio), OnOffAirFlowRatio);
+            SetAverageAirFlow(state, FurnaceNum, max(furnace.HeatPartLoadRatio, furnace.CoolPartLoadRatio), OnOffAirFlowRatio);
             //  if dehumidification load exists (for heat pumps) turn on the supplemental heater
             if (state.dataFurnaces->HPDehumidificationLoadFlag) HumControl = true;
         } else { // not FirstHVACIteration
@@ -6555,14 +5436,14 @@ namespace Furnaces {
             Real64 &CoolCoilLoad = state.dataFurnaces->CoolCoilLoad;
             if (state.dataFurnaces->HeatingLoad) {
                 CoolCoilLoad = 0.0;
-                if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                    (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && thisFurnace.WatertoAirHPType == WAHPCoilType::Simple)) {
+                if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                    (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && furnace.WatertoAirHPType == WAHPCoilType::Simple)) {
                     SystemSensibleLoad = ZoneLoad;
                     SystemMoistureLoad = 0.0;
                     HeatCoilLoad = 0.0;
-                    thisFurnace.HeatingCoilSensDemand = SystemSensibleLoad;
-                    thisFurnace.CoolingCoilSensDemand = 0.0;
-                    thisFurnace.CoolingCoilLatentDemand = 0.0;
+                    furnace.HeatingCoilSensDemand = SystemSensibleLoad;
+                    furnace.CoolingCoilSensDemand = 0.0;
+                    furnace.CoolingCoilLatentDemand = 0.0;
                 } else {
                     SystemMoistureLoad = MoistureLoad;
                     HeatCoilLoad = ZoneLoad;
@@ -6573,9 +5454,9 @@ namespace Furnaces {
                 CoolCoilLoad = ZoneLoad;
                 SystemMoistureLoad = MoistureLoad;
                 HeatCoilLoad = 0.0;
-                thisFurnace.CoolingCoilSensDemand = std::abs(CoolCoilLoad);
-                thisFurnace.CoolingCoilLatentDemand = std::abs(SystemMoistureLoad);
-                thisFurnace.HeatingCoilSensDemand = 0.0;
+                furnace.CoolingCoilSensDemand = std::abs(CoolCoilLoad);
+                furnace.CoolingCoilLatentDemand = std::abs(SystemMoistureLoad);
+                furnace.HeatingCoilSensDemand = 0.0;
 
                 // Init for latent
             } else {
@@ -6583,30 +5464,30 @@ namespace Furnaces {
                 CoolCoilLoad = 0.0;
                 HeatCoilLoad = 0.0;
                 // set report variables
-                thisFurnace.CoolingCoilSensDemand = 0.0;
-                thisFurnace.CoolingCoilLatentDemand = SystemMoistureLoad;
-                thisFurnace.HeatingCoilSensDemand = 0.0;
+                furnace.CoolingCoilSensDemand = 0.0;
+                furnace.CoolingCoilLatentDemand = SystemMoistureLoad;
+                furnace.HeatingCoilSensDemand = 0.0;
             }
             HeatingSensibleOutput = 0.0;
             HeatingLatentOutput = 0.0;
             ReheatCoilLoad = 0.0;
-            thisFurnace.CoolPartLoadRatio = 0.0;
-            thisFurnace.HeatPartLoadRatio = 0.0;
-            thisFurnace.CompPartLoadRatio = 0.0;
-            thisFurnace.DehumidInducedHeatingDemandRate = 0.0;
+            furnace.CoolPartLoadRatio = 0.0;
+            furnace.HeatPartLoadRatio = 0.0;
+            furnace.CompPartLoadRatio = 0.0;
+            furnace.DehumidInducedHeatingDemandRate = 0.0;
 
             // When humidity control is used with cycling fan control and a heating load exists, if a moisture load
             // also exists, the heating PLR must be available for the cooling coil calculations.
             //*********** Heating Section ************
             // If Furnace runs with a heating load then set HeatCoilLoad on Heating Coil and the Mass Flow
             //         (Node(FurnaceInletNode)%MassFlowRate .gt. 0.0d0) .and. &
-            if ((thisFurnace.availSched->getCurrentVal() > 0.0) && (state.dataFurnaces->HeatingLoad)) {
+            if ((furnace.availSched->getCurrentVal() > 0.0) && (state.dataFurnaces->HeatingLoad)) {
 
                 //    Heat pumps only calculate a single PLR each time step (i.e. only cooling or heating allowed in a single time step)
-                if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                    (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && thisFurnace.WatertoAirHPType == WAHPCoilType::Simple)) {
+                if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                    (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && furnace.WatertoAirHPType == WAHPCoilType::Simple)) {
 
-                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
 
                     // Get no load result
                     if (fanOp == HVAC::FanOp::Cycling) {
@@ -6619,7 +5500,7 @@ namespace Furnaces {
                     SetAverageAirFlow(state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
 
                     // Set the input parameters for CalcFurnaceOutput
-                    thisFurnace.CompPartLoadRatio = 0.0; // compressor off
+                    furnace.CompPartLoadRatio = 0.0; // compressor off
 
                     CalcFurnaceOutput(state,
                                       FurnaceNum,
@@ -6636,9 +5517,9 @@ namespace Furnaces {
                                       false);
 
                     PartLoadRatio = 1.0;
-                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
 
-                    thisFurnace.CompPartLoadRatio = 1.0; // compressor ON
+                    furnace.CompPartLoadRatio = 1.0; // compressor ON
 
                     // Set fan part-load fraction equal to 1 while getting full load result
                     state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
@@ -6664,7 +5545,7 @@ namespace Furnaces {
                     if (SystemSensibleLoad < FullSensibleOutput && SystemSensibleLoad > NoHeatOutput) {
 
                         // Calculate the part load ratio through iteration
-                        HeatErrorToler = thisFurnace.HeatingConvergenceTolerance; // Error tolerance for convergence from input deck
+                        HeatErrorToler = furnace.HeatingConvergenceTolerance; // Error tolerance for convergence from input deck
 
                         int SolFlag = 0; // # of iterations if positive, -1 means failed to converge, -2 means bounds are incorrect
                         // HeatErrorToler is in fraction of load, MaxIter = 30, SolFalg = # of iterations or error as appropriate
@@ -6700,11 +5581,11 @@ namespace Furnaces {
                                                   OnOffAirFlowRatio,
                                                   false);
                                 if (std::abs(SystemSensibleLoad - TempHeatOutput) > HVAC::SmallLoad) {
-                                    if (thisFurnace.DXHeatingMaxIterIndex == 0) {
+                                    if (furnace.DXHeatingMaxIterIndex == 0) {
                                         ShowWarningMessage(state,
                                                            format("Heating coil control failed to converge for {}:{}",
-                                                                  HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                  thisFurnace.Name));
+                                                                  HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                  furnace.Name));
                                         ShowContinueError(state,
                                                           "  Iteration limit exceeded in calculating DX heating coil sensible part-load ratio.");
                                         ShowContinueErrorTimeStamp(
@@ -6718,18 +5599,18 @@ namespace Furnaces {
                                                                    format("{} \"{}\" - Iteration limit exceeded in calculating DX sensible heating "
                                                                           "part-load ratio error continues. "
                                                                           "Sensible load statistics:",
-                                                                          HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                          thisFurnace.Name),
-                                                                   thisFurnace.DXHeatingMaxIterIndex,
+                                                                          HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                          furnace.Name),
+                                                                   furnace.DXHeatingMaxIterIndex,
                                                                    SystemSensibleLoad,
                                                                    SystemSensibleLoad);
                                 }
                             } else if (SolFlag == -2) {
-                                if (thisFurnace.DXHeatingRegulaFalsiFailedIndex == 0) {
+                                if (furnace.DXHeatingRegulaFalsiFailedIndex == 0) {
                                     ShowWarningMessage(state,
                                                        format("Heating coil control failed for {}:{}",
-                                                              HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                              thisFurnace.Name));
+                                                              HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                              furnace.Name));
                                     ShowContinueError(state, "  DX sensible heating part-load ratio determined to be outside the range of 0-1.");
                                     ShowContinueErrorTimeStamp(
                                         state,
@@ -6739,50 +5620,50 @@ namespace Furnaces {
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
                                     format("{} \"{}\" -  DX sensible heating part-load ratio out of range error continues. Sensible load statistics:",
-                                           HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                           thisFurnace.Name),
-                                    thisFurnace.DXHeatingRegulaFalsiFailedIndex,
+                                           HVAC::unitarySysTypeNames[(int)furnace.type],
+                                           furnace.Name),
+                                    furnace.DXHeatingRegulaFalsiFailedIndex,
                                     SystemSensibleLoad,
                                     SystemSensibleLoad);
                             }
                         }
 
-                        thisFurnace.HeatPartLoadRatio = PartLoadRatio;
+                        furnace.HeatPartLoadRatio = PartLoadRatio;
                         //       Check if Heat Pump compressor is allowed to run based on outdoor temperature
-                        if (OutdoorDryBulbTemp > thisFurnace.MinOATCompressorHeating) {
-                            thisFurnace.CompPartLoadRatio = PartLoadRatio;
+                        if (OutdoorDryBulbTemp > furnace.MinOATCompressorHeating) {
+                            furnace.CompPartLoadRatio = PartLoadRatio;
                         } else {
-                            thisFurnace.CompPartLoadRatio = 0.0;
+                            furnace.CompPartLoadRatio = 0.0;
                         }
                     } else if (SystemSensibleLoad > FullSensibleOutput) {
                         //       SystemSensibleLoad is greater than full DX Heating coil output so heat pump runs entire
                         //       timestep and additional supplemental heating is required
-                        thisFurnace.HeatPartLoadRatio = 1.0;
-                        if (OutdoorDryBulbTemp > thisFurnace.MinOATCompressorHeating) {
+                        furnace.HeatPartLoadRatio = 1.0;
+                        if (OutdoorDryBulbTemp > furnace.MinOATCompressorHeating) {
                             //       Check to see if Heat Pump compressor was allowed to run based on outdoor temperature
-                            thisFurnace.CompPartLoadRatio = 1.0;
+                            furnace.CompPartLoadRatio = 1.0;
                         } else {
-                            thisFurnace.CompPartLoadRatio = 0.0;
+                            furnace.CompPartLoadRatio = 0.0;
                         }
                     } else if (SystemSensibleLoad < NoHeatOutput) {
                         //       SystemSensibleLoad is less than minimum DX Heating coil output so heat pump does not run and
                         //       the load will be met by the supplemental heater
-                        thisFurnace.CompPartLoadRatio = 0.0;
-                        thisFurnace.HeatPartLoadRatio = 1.0;
+                        furnace.CompPartLoadRatio = 0.0;
+                        furnace.HeatPartLoadRatio = 1.0;
                     }
-                    if (thisFurnace.HeatPartLoadRatio == 1.0) {
+                    if (furnace.HeatPartLoadRatio == 1.0) {
                         //       Determine the load on the supplemental heating coil
-                        if ((SystemSensibleLoad - FullSensibleOutput) > thisFurnace.DesignSuppHeatingCapacity) {
-                            HeatCoilLoad = thisFurnace.DesignSuppHeatingCapacity;
-                            TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceOutletNode).Temp + HeatCoilLoad / (cpair * thisFurnace.MdotFurnace);
+                        if ((SystemSensibleLoad - FullSensibleOutput) > furnace.DesignSuppHeatingCapacity) {
+                            HeatCoilLoad = furnace.DesignSuppHeatingCapacity;
+                            TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceOutletNode).Temp + HeatCoilLoad / (cpair * furnace.MdotFurnace);
                         } else if (SystemSensibleLoad < NoHeatOutput) {
                             HeatCoilLoad = max(0.0, SystemSensibleLoad); // BG 10/22/2008 need a case for when its all suppl heat
-                            TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceInletNode).Temp + HeatCoilLoad / (cpair * thisFurnace.MdotFurnace);
+                            TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceInletNode).Temp + HeatCoilLoad / (cpair * furnace.MdotFurnace);
                         } else {
                             HeatCoilLoad = max(0.0, (SystemSensibleLoad - FullSensibleOutput));
-                            TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceOutletNode).Temp + HeatCoilLoad / (cpair * thisFurnace.MdotFurnace);
+                            TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceOutletNode).Temp + HeatCoilLoad / (cpair * furnace.MdotFurnace);
                         }
-                        if (OutdoorDryBulbTemp > thisFurnace.MaxOATSuppHeat) {
+                        if (OutdoorDryBulbTemp > furnace.MaxOATSuppHeat) {
                             HeatCoilLoad = 0.0;
                             if (SystemSensibleLoad < NoHeatOutput) {
                                 TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceInletNode).Temp;
@@ -6790,13 +5671,13 @@ namespace Furnaces {
                                 TempOutHeatingCoil = state.dataLoopNodes->Node(FurnaceOutletNode).Temp;
                             }
                         }
-                        if ((TempOutHeatingCoil > thisFurnace.DesignMaxOutletTemp) && (HeatCoilLoad > 0.0)) {
+                        if ((TempOutHeatingCoil > furnace.DesignMaxOutletTemp) && (HeatCoilLoad > 0.0)) {
                             // deltaT = Furnace(FurnaceNum)%DesignMaxOutletTemp - Node(FurnaceOutletNode)%Temp
                             // BG 10/22/2008 above made no sense if DX heat is off and its all supplemental,
                             //  because Node(FurnaceOutletNode)%Temp will have been calc'd with full DX heat in last faux call to CalcFurnaceOutput
 
                             Real64 cpairSupply = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(FurnaceInletNode).HumRat);
-                            deltaT = (thisFurnace.DesignMaxOutletTemp - TempOutHeatingCoil);
+                            deltaT = (furnace.DesignMaxOutletTemp - TempOutHeatingCoil);
                             HeatCoilLoad += (state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate * cpairSupply * deltaT);
                             HeatCoilLoad = max(0.0, HeatCoilLoad);
                         }
@@ -6810,8 +5691,8 @@ namespace Furnaces {
                 } else { // else not a heatpump DX coil ** non-HP heating coils are not DX so testing if OutdoorDryBulbTemp < MinOATCompressorHeating
                          // is not necessary **
 
-                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
-                    HeatCoilLoad = thisFurnace.DesignHeatingCapacity;
+                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
+                    HeatCoilLoad = furnace.DesignHeatingCapacity;
                     SystemSensibleLoad = ZoneLoad;
 
                     // Get no load result
@@ -6841,7 +5722,7 @@ namespace Furnaces {
                                       false);
 
                     if (NoHeatOutput < SystemSensibleLoad) {
-                        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+                        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
 
                         // Set fan part-load fraction equal to 1 while getting full load result
                         state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
@@ -6877,7 +5758,7 @@ namespace Furnaces {
                             if (state.dataFurnaces->ModifiedHeatCoilLoad > 0.0) {
                                 HeatCoilLoad = state.dataFurnaces->ModifiedHeatCoilLoad;
                             } else {
-                                HeatCoilLoad = thisFurnace.DesignHeatingCapacity;
+                                HeatCoilLoad = furnace.DesignHeatingCapacity;
                             }
                         } else if (NoHeatOutput >= SystemSensibleLoad) {
                             PartLoadRatio = 0.0;
@@ -6885,7 +5766,7 @@ namespace Furnaces {
                         } else {
 
                             // Calculate the part load ratio through iteration
-                            HeatErrorToler = thisFurnace.HeatingConvergenceTolerance; // Error tolerance for convergence from input deck
+                            HeatErrorToler = furnace.HeatingConvergenceTolerance; // Error tolerance for convergence from input deck
 
                             int SolFlag = 0; // # of iterations if positive, -1 means failed to converge, -2 means bounds are incorrect
                             // HeatErrorToler is in fraction load, MaxIter = 30, SolFalg = # of iterations or error as appropriate
@@ -6910,7 +5791,7 @@ namespace Furnaces {
                             if (state.dataFurnaces->ModifiedHeatCoilLoad > 0.0) {
                                 HeatCoilLoad = state.dataFurnaces->ModifiedHeatCoilLoad;
                             } else {
-                                HeatCoilLoad = thisFurnace.DesignHeatingCapacity * PartLoadRatio;
+                                HeatCoilLoad = furnace.DesignHeatingCapacity * PartLoadRatio;
                             }
                             if (SolFlag == -1) {
 
@@ -6921,7 +5802,7 @@ namespace Furnaces {
                                 while ((TempHeatOutput - SystemSensibleLoad) < 0.0 && TempMaxPLR < 1.0) {
                                     //             find upper limit of HeatingPLR
                                     TempMaxPLR += 0.1;
-                                    HeatCoilLoad = thisFurnace.DesignHeatingCapacity * TempMaxPLR;
+                                    HeatCoilLoad = furnace.DesignHeatingCapacity * TempMaxPLR;
                                     CalcFurnaceOutput(state,
                                                       FurnaceNum,
                                                       FirstHVACIteration,
@@ -6944,7 +5825,7 @@ namespace Furnaces {
                                     //             find minimum limit of HeatingPLR
                                     TempMinPLR -= 0.01;
 
-                                    HeatCoilLoad = thisFurnace.DesignHeatingCapacity * TempMinPLR;
+                                    HeatCoilLoad = furnace.DesignHeatingCapacity * TempMinPLR;
                                     CalcFurnaceOutput(state,
                                                       FurnaceNum,
                                                       FirstHVACIteration,
@@ -6978,7 +5859,7 @@ namespace Furnaces {
                                 if (state.dataFurnaces->ModifiedHeatCoilLoad > 0.0) {
                                     HeatCoilLoad = state.dataFurnaces->ModifiedHeatCoilLoad;
                                 } else {
-                                    HeatCoilLoad = thisFurnace.DesignHeatingCapacity * PartLoadRatio;
+                                    HeatCoilLoad = furnace.DesignHeatingCapacity * PartLoadRatio;
                                 }
                                 CalcFurnaceOutput(state,
                                                   FurnaceNum,
@@ -6996,11 +5877,11 @@ namespace Furnaces {
 
                                 //           After iterating with tighter boundaries, if still out of tolerance, show warning.
                                 if (SolFlag == -1 && std::abs(SystemSensibleLoad - TempHeatOutput) > HVAC::SmallLoad) {
-                                    if (thisFurnace.HeatingMaxIterIndex == 0) {
+                                    if (furnace.HeatingMaxIterIndex == 0) {
                                         ShowWarningMessage(state,
                                                            format("Heating coil control failed to converge for {}:{}",
-                                                                  HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                  thisFurnace.Name));
+                                                                  HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                  furnace.Name));
                                         ShowContinueError(state, "  Iteration limit exceeded in calculating heating coil sensible part-load ratio.");
                                         ShowContinueErrorTimeStamp(state,
                                                                    format("Sensible load to be met by heating coil = {:.2T} (watts), sensible output "
@@ -7012,18 +5893,18 @@ namespace Furnaces {
                                         state,
                                         format("{} \"{}\" - Iteration limit exceeded in calculating sensible heating part-load "
                                                "ratio error continues. Sensible load statistics:",
-                                               HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                               thisFurnace.Name),
-                                        thisFurnace.HeatingMaxIterIndex,
+                                               HVAC::unitarySysTypeNames[(int)furnace.type],
+                                               furnace.Name),
+                                        furnace.HeatingMaxIterIndex,
                                         SystemSensibleLoad,
                                         SystemSensibleLoad);
                                 }
                             } else if (SolFlag == -2) {
-                                if (thisFurnace.HeatingRegulaFalsiFailedIndex == 0) {
+                                if (furnace.HeatingRegulaFalsiFailedIndex == 0) {
                                     ShowWarningMessage(state,
                                                        format("Heating coil control failed for {}:{}",
-                                                              HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                              thisFurnace.Name));
+                                                              HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                              furnace.Name));
                                     ShowContinueError(state, "  Sensible heating part-load ratio determined to be outside the range of 0-1.");
                                     ShowContinueErrorTimeStamp(
                                         state,
@@ -7033,9 +5914,9 @@ namespace Furnaces {
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
                                     format("{} \"{}\" -  Sensible heating part-load ratio out of range error continues. Sensible load statistics:",
-                                           HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                           thisFurnace.Name),
-                                    thisFurnace.HeatingRegulaFalsiFailedIndex,
+                                           HVAC::unitarySysTypeNames[(int)furnace.type],
+                                           furnace.Name),
+                                    furnace.HeatingRegulaFalsiFailedIndex,
                                     SystemSensibleLoad,
                                     SystemSensibleLoad);
                             }
@@ -7044,7 +5925,7 @@ namespace Furnaces {
                     } else { // ELSE from IF(FullSensibleOutput.GT.NoSensibleOutput)THEN above
                         // Set part load ratio to 1 and run heater at design heating capacity
                         PartLoadRatio = 1.0;
-                        HeatCoilLoad = thisFurnace.DesignHeatingCapacity;
+                        HeatCoilLoad = furnace.DesignHeatingCapacity;
                     }
 
                 } // End of IF HeatPump
@@ -7053,14 +5934,14 @@ namespace Furnaces {
 
             // Non-heat pump systems do not set a heating PLR, set it here for use with the DX cooling coil calculations.
             // Set this variable back to 0 for non-heat pump systems at the end of this routine.
-            thisFurnace.HeatPartLoadRatio = max(PartLoadRatio, thisFurnace.HeatPartLoadRatio);
+            furnace.HeatPartLoadRatio = max(PartLoadRatio, furnace.HeatPartLoadRatio);
             CalcFurnaceOutput(state,
                               FurnaceNum,
                               FirstHVACIteration,
                               fanOp,
                               compressorOp,
                               0.0,
-                              thisFurnace.HeatPartLoadRatio,
+                              furnace.HeatPartLoadRatio,
                               HeatCoilLoad,
                               0.0,
                               HeatingSensibleOutput,
@@ -7068,8 +5949,8 @@ namespace Furnaces {
                               OnOffAirFlowRatio,
                               false);
 
-            if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && thisFurnace.WatertoAirHPType == WAHPCoilType::Simple &&
+            if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && furnace.WatertoAirHPType == WAHPCoilType::Simple &&
                  state.dataFurnaces->CoolingLoad)) {
                 HeatingSensibleOutput = 0.0;
                 HeatingLatentOutput = 0.0;
@@ -7078,10 +5959,10 @@ namespace Furnaces {
             // Simulate if scheduled ON and cooling load or if a moisture load exists when using a humidistat
             // Check of HeatingLatentOutput is used to reduce overshoot during simultaneous heating and cooling
             // Setback flag is used to avoid continued RH control when Tstat is setback (RH should float down)
-            if ((thisFurnace.availSched->getCurrentVal() > 0.0 && state.dataFurnaces->CoolingLoad) ||
-                (thisFurnace.Humidistat && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat &&
+            if ((furnace.availSched->getCurrentVal() > 0.0 && state.dataFurnaces->CoolingLoad) ||
+                (furnace.Humidistat && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat &&
                  (SystemMoistureLoad < 0.0 || (SystemMoistureLoad >= 0.0 && HeatingLatentOutput > SystemMoistureLoad &&
-                                               !state.dataZoneEnergyDemand->Setback(thisFurnace.ControlZoneNum))))) {
+                                               !state.dataZoneEnergyDemand->Setback(furnace.ControlZoneNum))))) {
 
                 //     For cooling operation, the first step is to set the HX operation flag in case a HX assisted coil is used.
                 //      (if a HX assisted coil is not used, this flag is not used. It's only used in the CALL to SimHXAssistedCoolingCoil)
@@ -7090,8 +5971,8 @@ namespace Furnaces {
                 //           For dehumidification control option Multimode, the system is operated first with the HX off.
                 //           If the moisture load is not met, the HX will then be turned on and the system is re-simulated.
 
-                if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat ||
-                    thisFurnace.DehumidControlType_Num == DehumidificationControlMode::None) {
+                if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat ||
+                    furnace.DehumidControlType_Num == DehumidificationControlMode::None) {
                     HXUnitOn = true;
                 } else {
                     HXUnitOn = false;
@@ -7102,17 +5983,17 @@ namespace Furnaces {
                 //     Set the inlet mass flow rate based on user specified coil OFF flow rate
                 PartLoadRatio = 0.0;
 
-                thisFurnace.CompPartLoadRatio = 0.0; // compressor off
+                furnace.CompPartLoadRatio = 0.0; // compressor off
 
                 //     SetAverageAirFlow calculates the operating mass flow rate based on PLR and the user specified inputs
                 //     for MaxCoolAirMassFlow and MaxNoCoolHeatAirMassFlow.
                 //     Air flow rate is set according to max of cooling and heating PLR if heating and latent load exists.
-                if (fanOp == HVAC::FanOp::Cycling && thisFurnace.HeatPartLoadRatio > 0.0 && thisFurnace.Humidistat &&
-                    thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat &&
+                if (fanOp == HVAC::FanOp::Cycling && furnace.HeatPartLoadRatio > 0.0 && furnace.Humidistat &&
+                    furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat &&
                     (SystemMoistureLoad < 0.0 || (SystemMoistureLoad >= 0.0 && HeatingLatentOutput > SystemMoistureLoad &&
-                                                  !state.dataZoneEnergyDemand->Setback(thisFurnace.ControlZoneNum)))) {
-                    CoolingHeatingPLRRatio = min(1.0, PartLoadRatio / thisFurnace.HeatPartLoadRatio);
-                    SetAverageAirFlow(state, FurnaceNum, max(PartLoadRatio, thisFurnace.HeatPartLoadRatio), OnOffAirFlowRatio);
+                                                  !state.dataZoneEnergyDemand->Setback(furnace.ControlZoneNum)))) {
+                    CoolingHeatingPLRRatio = min(1.0, PartLoadRatio / furnace.HeatPartLoadRatio);
+                    SetAverageAirFlow(state, FurnaceNum, max(PartLoadRatio, furnace.HeatPartLoadRatio), OnOffAirFlowRatio);
 
                 } else {
                     CoolingHeatingPLRRatio = 1.0;
@@ -7138,13 +6019,13 @@ namespace Furnaces {
                 //     Don't calculate full load output if no load output can meet sensible load
                 if (NoCoolOutput >= CoolCoilLoad && (CoolCoilLoad != 0.0 || state.dataFurnaces->HPDehumidificationLoadFlag)) {
                     //       Set full mass flow rate for full load calculation
-                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+                    state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
 
                     // Set fan part-load fraction equal to 1 while getting full load result
                     state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
                     OnOffAirFlowRatio = 1.0;
                     PartLoadRatio = 1.0;
-                    thisFurnace.CompPartLoadRatio = 1.0; // compressor ON
+                    furnace.CompPartLoadRatio = 1.0; // compressor ON
 
                     // Get full load result (coils simulated full ON)
                     CalcFurnaceOutput(state,
@@ -7184,7 +6065,7 @@ namespace Furnaces {
                         } else {
 
                             // Calculate the sensible part load ratio through iteration
-                            CoolErrorToler = thisFurnace.CoolingConvergenceTolerance; // Error tolerance for convergence from input deck
+                            CoolErrorToler = furnace.CoolingConvergenceTolerance; // Error tolerance for convergence from input deck
                             int SolFlag = 0; // # of iterations if positive, -1 means failed to converge, -2 means bounds are incorrect
                             Real64 par8_HXFlag = HXUnitOn ? 1.0 : 0.0;
                             // CoolErrorToler is in fraction of load, MaxIter = 30, SolFalg = # of iterations or error as appropriate
@@ -7222,11 +6103,11 @@ namespace Furnaces {
                                                       HXUnitOn);
                                     if (!state.dataGlobal->WarmupFlag) {
                                         if (std::abs(CoolCoilLoad - TempCoolOutput) > HVAC::SmallLoad) {
-                                            if (thisFurnace.SensibleMaxIterIndex == 0) {
+                                            if (furnace.SensibleMaxIterIndex == 0) {
                                                 ShowWarningMessage(state,
                                                                    format("Cooling coil control failed to converge for {}:{}",
-                                                                          HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                          thisFurnace.Name));
+                                                                          HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                          furnace.Name));
                                                 ShowContinueError(
                                                     state, "  Iteration limit exceeded in calculating DX cooling coil sensible part-load ratio.");
                                                 ShowContinueErrorTimeStamp(state,
@@ -7239,20 +6120,20 @@ namespace Furnaces {
                                                 state,
                                                 format("{} \"{}\" - Iteration limit exceeded in calculating sensible cooling "
                                                        "part-load ratio error continues. Sensible load statistics:",
-                                                       HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                       thisFurnace.Name),
-                                                thisFurnace.SensibleMaxIterIndex,
+                                                       HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                       furnace.Name),
+                                                furnace.SensibleMaxIterIndex,
                                                 CoolCoilLoad,
                                                 CoolCoilLoad);
                                         }
                                     }
                                 } else if (SolFlag == -2) {
                                     if (!state.dataGlobal->WarmupFlag) {
-                                        if (thisFurnace.SensibleRegulaFalsiFailedIndex == 0) {
+                                        if (furnace.SensibleRegulaFalsiFailedIndex == 0) {
                                             ShowWarningMessage(state,
                                                                format("Cooling coil control failed for {}:{}",
-                                                                      HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                      thisFurnace.Name));
+                                                                      HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                      furnace.Name));
                                             ShowContinueError(state, "  Cooling sensible part-load ratio determined to be outside the range of 0-1.");
                                             ShowContinueErrorTimeStamp(state, format("  Cooling sensible load = {:.2T}", CoolCoilLoad));
                                         }
@@ -7260,9 +6141,9 @@ namespace Furnaces {
                                             state,
                                             format("{} \"{}\" - Cooling sensible part-load ratio out of range error continues. Sensible cooling load "
                                                    "statistics:",
-                                                   HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                   thisFurnace.Name),
-                                            thisFurnace.SensibleRegulaFalsiFailedIndex,
+                                                   HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                   furnace.Name),
+                                            furnace.SensibleRegulaFalsiFailedIndex,
                                             CoolCoilLoad,
                                             CoolCoilLoad);
                                     }
@@ -7281,7 +6162,7 @@ namespace Furnaces {
                                       fanOp,
                                       compressorOp,
                                       PartLoadRatio,
-                                      thisFurnace.HeatPartLoadRatio,
+                                      furnace.HeatPartLoadRatio,
                                       0.0,
                                       0.0,
                                       TempCoolOutput,
@@ -7294,19 +6175,19 @@ namespace Furnaces {
                     //       IF this furnace uses MultiMode control AND there is a moisture load AND the moisture load met by the furnace in
                     //       cooling only mode above is sufficient to meet the moisture demand OR there is no sensible load (PLR=0 from above)
                     //       then set LatentPartLoadRatio to 0 (no additional dehumidification is required).
-                    if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::Multimode &&
+                    if (furnace.DehumidControlType_Num == DehumidificationControlMode::Multimode &&
                         ((SystemMoistureLoad < 0.0 && TempLatentOutput < SystemMoistureLoad) || PartLoadRatio == 0.0)) {
                         LatentPartLoadRatio = 0.0;
                         //       ELSE calculate a new PLR for valid dehumidification control types if a moisture load exists.
-                    } else if (thisFurnace.DehumidControlType_Num != DehumidificationControlMode::None &&
+                    } else if (furnace.DehumidControlType_Num != DehumidificationControlMode::None &&
                                (SystemMoistureLoad < 0.0 || (SystemMoistureLoad >= 0.0 && TempLatentOutput > SystemMoistureLoad &&
-                                                             !state.dataZoneEnergyDemand->Setback(thisFurnace.ControlZoneNum)))) {
+                                                             !state.dataZoneEnergyDemand->Setback(furnace.ControlZoneNum)))) {
 
                         //         IF the furnace uses dehumidification control MultiMode, turn on the HX and calculate the latent output with
                         //         the HX ON to compare to the moisture load predicted by the humidistat.
-                        if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
+                        if (furnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
                             HXUnitOn = true;
-                            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+                            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
                             // Set fan part-load fraction equal to 1 while getting full load result
                             state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
                             OnOffAirFlowRatio = 1.0;
@@ -7331,12 +6212,12 @@ namespace Furnaces {
 
                         if (TempLatentOutput > SystemMoistureLoad) {
                             //           Set full mass flow rate for full load calculation
-                            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+                            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
 
                             // Set fan part-load fraction equal to 1 while getting full load result
                             state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
                             OnOffAirFlowRatio = 1.0;
-                            thisFurnace.CompPartLoadRatio = 1.0; // compressor ON
+                            furnace.CompPartLoadRatio = 1.0; // compressor ON
 
                             // Get full load result (coils simulated full ON)
                             CalcFurnaceOutput(state,
@@ -7356,33 +6237,33 @@ namespace Furnaces {
 
                         // check bounds on latent output prior to iteration using RegulaFalsi
                         if (TempLatentOutput > SystemMoistureLoad ||
-                            (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::Multimode && TempCoolOutput > CoolCoilLoad)) {
+                            (furnace.DehumidControlType_Num == DehumidificationControlMode::Multimode && TempCoolOutput > CoolCoilLoad)) {
                             LatentPartLoadRatio = 1.0;
                         } else if (NoLatentOutput < SystemMoistureLoad || HeatingLatentOutput < SystemMoistureLoad) {
                             LatentPartLoadRatio = 0.0;
                         } else {
 
-                            CoolErrorToler = thisFurnace.CoolingConvergenceTolerance; // Error tolerance for convergence
+                            CoolErrorToler = furnace.CoolingConvergenceTolerance; // Error tolerance for convergence
 
                             int SolFlag = 0; // # of iterations if positive, -1 means failed to converge, -2 means bounds are incorrect
                             // Multimode always controls to meet the SENSIBLE load (however, HXUnitOn is now TRUE)
                             Real64 par4_load;
-                            if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
+                            if (furnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
                                 par4_load = CoolCoilLoad;
                             } else {
                                 par4_load = SystemMoistureLoad;
                             }
                             // Multimode always controls to meet the SENSIBLE load (however, HXUnitOn is now TRUE)
                             Real64 par6_LatentSens;
-                            if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
+                            if (furnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
                                 par6_LatentSens = 1.0;
                             } else {
                                 par6_LatentSens = 0.0;
                             }
                             Real64 par8_HXUnit = HXUnitOn ? 1.0 : 0.0;
                             Real64 par9_HtgCoilPLR;
-                            if (fanOp == HVAC::FanOp::Cycling && thisFurnace.HeatPartLoadRatio > 0.0 && par6_LatentSens == 0.0) {
-                                par9_HtgCoilPLR = thisFurnace.HeatPartLoadRatio;
+                            if (fanOp == HVAC::FanOp::Cycling && furnace.HeatPartLoadRatio > 0.0 && par6_LatentSens == 0.0) {
+                                par9_HtgCoilPLR = furnace.HeatPartLoadRatio;
                             } else {
                                 par9_HtgCoilPLR = 0.0;
                             }
@@ -7428,7 +6309,7 @@ namespace Furnaces {
                                         //                 Par(10) = Furnace(FurnaceNum)%HeatPartLoadRatio
                                         //                 fanOp = CycFan and Furnace(FurnaceNum)%HeatPartLoadRatio must be > 0 for Part(10) to be
                                         //                 greater than 0
-                                        CoolingHeatingPLRRatio = min(1.0, TempMaxPLR / thisFurnace.HeatPartLoadRatio);
+                                        CoolingHeatingPLRRatio = min(1.0, TempMaxPLR / furnace.HeatPartLoadRatio);
                                     } else {
                                         CoolingHeatingPLRRatio = 1.0;
                                     }
@@ -7464,7 +6345,7 @@ namespace Furnaces {
                                         //                 the PLR to be 0, otherwise RegulaFalsi can fail when a heating and moisture load exists and
                                         //                 heating PLR > latent PLR.
                                         TempMinPLR2 = max(0.0000000001, TempMinPLR);
-                                        CoolingHeatingPLRRatio = min(1.0, TempMinPLR2 / thisFurnace.HeatPartLoadRatio);
+                                        CoolingHeatingPLRRatio = min(1.0, TempMinPLR2 / furnace.HeatPartLoadRatio);
                                     } else {
                                         TempMinPLR2 = TempMinPLR;
                                         CoolingHeatingPLRRatio = 1.0;
@@ -7517,7 +6398,7 @@ namespace Furnaces {
                                         //                 Par(10) = Furnace(FurnaceNum)%HeatPartLoadRatio
                                         //                 fanOp = CycFan and Furnace(FurnaceNum)%HeatPartLoadRatio must be > 0 for Part(10) to be
                                         //                 greater than 0
-                                        CoolingHeatingPLRRatio = min(1.0, LatentPartLoadRatio / thisFurnace.HeatPartLoadRatio);
+                                        CoolingHeatingPLRRatio = min(1.0, LatentPartLoadRatio / furnace.HeatPartLoadRatio);
                                     } else {
                                         CoolingHeatingPLRRatio = 1.0;
                                     }
@@ -7539,11 +6420,11 @@ namespace Furnaces {
                                     if (std::abs((SystemMoistureLoad - TempLatentOutput) / SystemMoistureLoad) > CoolErrorToler &&
                                         std::abs(SystemMoistureLoad - TempLatentOutput) > 10.0) {
                                         if (!state.dataGlobal->WarmupFlag) {
-                                            if (thisFurnace.LatentMaxIterIndex == 0) {
+                                            if (furnace.LatentMaxIterIndex == 0) {
                                                 ShowWarningMessage(state,
                                                                    format("Cooling coil control failed to converge for {}:{}",
-                                                                          HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                          thisFurnace.Name));
+                                                                          HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                          furnace.Name));
                                                 ShowContinueError(state,
                                                                   "  Iteration limit exceeded in calculating cooling coil latent part-load ratio.");
                                                 ShowContinueError(
@@ -7561,19 +6442,19 @@ namespace Furnaces {
                                                 format("{} \"{}\" - Iteration limit exceeded in calculating latent part-load ratio error continues. "
                                                        "Latent "
                                                        "load convergence error (percent) statistics follow.",
-                                                       HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                       thisFurnace.Name),
-                                                thisFurnace.LatentMaxIterIndex,
+                                                       HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                       furnace.Name),
+                                                furnace.LatentMaxIterIndex,
                                                 100.0 * std::abs((SystemMoistureLoad - TempLatentOutput) / SystemMoistureLoad),
                                                 100.0 * std::abs((SystemMoistureLoad - TempLatentOutput) / SystemMoistureLoad));
                                         }
                                     }
                                 } else if (SolFlag == -2) {
-                                    if (thisFurnace.LatentRegulaFalsiFailedIndex2 == 0) {
+                                    if (furnace.LatentRegulaFalsiFailedIndex2 == 0) {
                                         ShowWarningMessage(state,
                                                            format("Cooling coil control failed for {}:{}",
-                                                                  HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                  thisFurnace.Name));
+                                                                  HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                  furnace.Name));
                                         ShowContinueError(state,
                                                           format("  Latent part-load ratio determined to be outside the range of {:.3T} to {:.3T}.",
                                                                  TempMinPLR,
@@ -7584,28 +6465,28 @@ namespace Furnaces {
                                     ShowRecurringWarningErrorAtEnd(state,
                                                                    format("{} \"{}\" - Cooling sensible part-load ratio out of range error "
                                                                           "continues. System moisture load statistics:",
-                                                                          HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                                          thisFurnace.Name),
-                                                                   thisFurnace.LatentRegulaFalsiFailedIndex2,
+                                                                          HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                                          furnace.Name),
+                                                                   furnace.LatentRegulaFalsiFailedIndex2,
                                                                    SystemMoistureLoad,
                                                                    SystemMoistureLoad);
                                     LatentPartLoadRatio = TempMinPLR;
                                 }
                             } else if (SolFlag == -2) {
-                                if (thisFurnace.LatentRegulaFalsiFailedIndex == 0) {
+                                if (furnace.LatentRegulaFalsiFailedIndex == 0) {
                                     ShowWarningMessage(state,
                                                        format("Cooling coil control failed for {}:{}",
-                                                              HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                              thisFurnace.Name));
+                                                              HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                              furnace.Name));
                                     ShowContinueError(state, "  Latent part-load ratio determined to be outside the range of 0-1.");
                                     ShowContinueErrorTimeStamp(state, "A PLR of 0 will be used and the simulation continues.");
                                 }
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
                                     format("{} \"{}\" - Latent part-load ratio out of range or 0-1 error continues. System moisture load statistics:",
-                                           HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                           thisFurnace.Name),
-                                    thisFurnace.LatentRegulaFalsiFailedIndex,
+                                           HVAC::unitarySysTypeNames[(int)furnace.type],
+                                           furnace.Name),
+                                    furnace.LatentRegulaFalsiFailedIndex,
                                     SystemMoistureLoad,
                                     SystemMoistureLoad);
                                 LatentPartLoadRatio = 0.0;
@@ -7636,10 +6517,10 @@ namespace Furnaces {
 
                     //       IF a humidistat is used and there is a moisture load, check if the latent PLR is greater than the (sensible) PLR
                     //        IF(LatentPartLoadRatio .GT. PartLoadRatio .and. SystemMoistureLoad .lt. 0.0 .and. Furnace(FurnaceNum)%Humidistat) THEN
-                    if (LatentPartLoadRatio > PartLoadRatio && thisFurnace.Humidistat) {
+                    if (LatentPartLoadRatio > PartLoadRatio && furnace.Humidistat) {
                         // For dehumidification mode CoolReheat, compare the Sensible and Latent PLR values, if latentPLR is greater
                         // than PLR (sensible), then overcooling is required and reheat will be activated using the HumControl flag.
-                        if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
+                        if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat) {
                             PartLoadRatio = LatentPartLoadRatio;
                             HumControl = true;
                         }
@@ -7647,16 +6528,16 @@ namespace Furnaces {
                         // greater than PLR (sensible), then use the latent PLR to control the unit.
                         // For MultiMode control, the latent PLR is found by enabling the HX and calculating a PLR required to meet the
                         // sensible load. Overcooling is not required, and reheat will not be activated using the HumControl flag.
-                        if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
+                        if (furnace.DehumidControlType_Num == DehumidificationControlMode::Multimode) {
                             PartLoadRatio = LatentPartLoadRatio;
                         }
                     }
 
-                    thisFurnace.CoolPartLoadRatio = PartLoadRatio;
+                    furnace.CoolPartLoadRatio = PartLoadRatio;
                     if (compressorOp == HVAC::CompressorOp::Off) {
-                        thisFurnace.CompPartLoadRatio = 0.0;
+                        furnace.CompPartLoadRatio = 0.0;
                     } else {
-                        thisFurnace.CompPartLoadRatio = PartLoadRatio;
+                        furnace.CompPartLoadRatio = PartLoadRatio;
                     }
 
                 } else { // ELSE from IF(FullSensibleOutput.LT.NoCoolOutput)THEN above
@@ -7671,27 +6552,27 @@ namespace Furnaces {
                     // Additional logic is used here to make sure the coil actually turned on, e.g., if DX coil PLR > 0 then set to 1,
                     // otherwise 0 (to make sure coil is actually ON and not off due to schedule, OAT, or other reason).
                     // The global variable DXCoilPartLoadRatio(DXCoilNum) is not yet used for the WSHP to make the same check.
-                    if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
-                        thisFurnace.CoolPartLoadRatio = 0.0;
-                        thisFurnace.CompPartLoadRatio = 0.0;
+                    if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+                        furnace.CoolPartLoadRatio = 0.0;
+                        furnace.CompPartLoadRatio = 0.0;
                     } else {
-                        if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
+                        if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
 
                             // VS coil issue here...
-                            if (state.dataDXCoils->DXCoilPartLoadRatio(thisFurnace.ActualDXCoilIndexForHXAssisted) > 0.0) {
-                                thisFurnace.CoolPartLoadRatio = 1.0;
-                                thisFurnace.CompPartLoadRatio = 1.0;
+                            if (state.dataDXCoils->DXCoilPartLoadRatio(furnace.ActualDXCoilIndexForHXAssisted) > 0.0) {
+                                furnace.CoolPartLoadRatio = 1.0;
+                                furnace.CompPartLoadRatio = 1.0;
                             } else {
-                                thisFurnace.CoolPartLoadRatio = 0.0;
-                                thisFurnace.CompPartLoadRatio = 0.0;
+                                furnace.CoolPartLoadRatio = 0.0;
+                                furnace.CompPartLoadRatio = 0.0;
                             }
                         } else {
-                            if (state.dataDXCoils->DXCoilPartLoadRatio(thisFurnace.CoolingCoilIndex) > 0.0) {
-                                thisFurnace.CoolPartLoadRatio = 1.0;
-                                thisFurnace.CompPartLoadRatio = 1.0;
+                            if (state.dataDXCoils->DXCoilPartLoadRatio(furnace.CoolCoilNum) > 0.0) {
+                                furnace.CoolPartLoadRatio = 1.0;
+                                furnace.CompPartLoadRatio = 1.0;
                             } else {
-                                thisFurnace.CoolPartLoadRatio = 0.0;
-                                thisFurnace.CompPartLoadRatio = 0.0;
+                                furnace.CoolPartLoadRatio = 0.0;
+                                furnace.CompPartLoadRatio = 0.0;
                             }
                         }
                     }
@@ -7699,32 +6580,32 @@ namespace Furnaces {
 
                 //     Calculate the reheat coil output
                 if (HumControl) { // HumControl = .TRUE. if a Humidistat is installed and dehumidification control type is CoolReheat
-                    if (thisFurnace.ZoneSequenceHeatingNum > 0) {
-                        QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum)
-                                            .SequencedOutputRequiredToHeatingSP(thisFurnace.ZoneSequenceHeatingNum) /
-                                        thisFurnace.ControlZoneMassFlowFrac);
+                    if (furnace.ZoneSequenceHeatingNum > 0) {
+                        QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum)
+                                            .SequencedOutputRequiredToHeatingSP(furnace.ZoneSequenceHeatingNum) /
+                                        furnace.ControlZoneMassFlowFrac);
                     } else {
-                        QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum).OutputRequiredToHeatingSP /
-                                        thisFurnace.ControlZoneMassFlowFrac);
+                        QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum).OutputRequiredToHeatingSP /
+                                        furnace.ControlZoneMassFlowFrac);
                     }
                     //       Cooling mode or floating condition and dehumidification is required
                     if (QToHeatSetPt < 0.0) {
                         //         Calculate the reheat coil load wrt the heating setpoint temperature. Reheat coil picks up
                         //         the entire excess sensible cooling (DX cooling coil and impact of outdoor air).
                         ReheatCoilLoad = max(0.0, (QToHeatSetPt - ActualSensibleOutput));
-                        thisFurnace.DehumidInducedHeatingDemandRate = ReheatCoilLoad;
+                        furnace.DehumidInducedHeatingDemandRate = ReheatCoilLoad;
                         //       Heating mode and dehumidification is required
                     } else {
                         //         Calculate the reheat coil load as the sensible capacity of the DX cooling coil only. Let
                         //         the heating coil pick up the load due to outdoor air.
                         ReheatCoilLoad = max(0.0, (ActualSensibleOutput - NoCoolOutput) * (-1.0));
                         //         Dehumidification is not required
-                        if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                            (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir &&
-                             thisFurnace.WatertoAirHPType == WAHPCoilType::Simple)) {
+                        if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                            (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir &&
+                             furnace.WatertoAirHPType == WAHPCoilType::Simple)) {
                             ReheatCoilLoad = max(QToHeatSetPt, QToHeatSetPt - ActualSensibleOutput);
                         }
-                        thisFurnace.DehumidInducedHeatingDemandRate = max(0.0, ActualSensibleOutput * (-1.0));
+                        furnace.DehumidInducedHeatingDemandRate = max(0.0, ActualSensibleOutput * (-1.0));
                     }
                 } else {
                     //       No humidistat installed
@@ -7743,48 +6624,48 @@ namespace Furnaces {
             if (HumControl && SystemMoistureLoad < 0.0) {
                 if (fanOp == HVAC::FanOp::Cycling) {
                     //       set the flow rate at the maximum of the cooling and heating PLR's
-                    SetAverageAirFlow(state, FurnaceNum, max(thisFurnace.CoolPartLoadRatio, thisFurnace.HeatPartLoadRatio), OnOffAirFlowRatio);
+                    SetAverageAirFlow(state, FurnaceNum, max(furnace.CoolPartLoadRatio, furnace.HeatPartLoadRatio), OnOffAirFlowRatio);
                 } else {
                     //       ELSE set the flow rate at the cooling PLR
-                    SetAverageAirFlow(state, FurnaceNum, thisFurnace.CoolPartLoadRatio, OnOffAirFlowRatio);
+                    SetAverageAirFlow(state, FurnaceNum, furnace.CoolPartLoadRatio, OnOffAirFlowRatio);
                 }
             } else {
-                SetAverageAirFlow(state, FurnaceNum, max(thisFurnace.CoolPartLoadRatio, thisFurnace.HeatPartLoadRatio), OnOffAirFlowRatio);
+                SetAverageAirFlow(state, FurnaceNum, max(furnace.CoolPartLoadRatio, furnace.HeatPartLoadRatio), OnOffAirFlowRatio);
             }
-            thisFurnace.MdotFurnace = state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate;
+            furnace.MdotFurnace = state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate;
 
-            if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
-                (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && thisFurnace.WatertoAirHPType == WAHPCoilType::Simple)) {
+            if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir ||
+                (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && furnace.WatertoAirHPType == WAHPCoilType::Simple)) {
             } else {
                 // Non-HeatPump (non-DX) heating coils do not set PLR, reset to 0 here. This variable was set for non-DX
                 // coils to allow the SetAverageAirFlow CALL above to set the correct air mass flow rate. See this
                 // IF block above in heating section. HeatPLR is not set in the ELSE part of the IF (only HeatCoilLoad is set).
-                thisFurnace.HeatPartLoadRatio = 0.0;
+                furnace.HeatPartLoadRatio = 0.0;
             }
 
             //*********HVAC Scheduled OFF*************
             // No heating or cooling or dehumidification
             //!!LKL discrepancy with < 0?
-            if (thisFurnace.availSched->getCurrentVal() == 0.0 || state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate == 0.0) {
-                thisFurnace.MdotFurnace = 0.0;
+            if (furnace.availSched->getCurrentVal() == 0.0 || state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate == 0.0) {
+                furnace.MdotFurnace = 0.0;
                 CoolCoilLoad = 0.0;
                 HeatCoilLoad = 0.0;
                 ReheatCoilLoad = 0.0;
                 state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; // System off, so set on/off fan part-load fraction = 1
-                thisFurnace.CoolPartLoadRatio = 0.0;
-                thisFurnace.HeatPartLoadRatio = 0.0;
-                thisFurnace.CompPartLoadRatio = 0.0;
+                furnace.CoolPartLoadRatio = 0.0;
+                furnace.HeatPartLoadRatio = 0.0;
+                furnace.CompPartLoadRatio = 0.0;
                 // set report variables
-                thisFurnace.CoolingCoilSensDemand = 0.0;
-                thisFurnace.CoolingCoilLatentDemand = 0.0;
-                thisFurnace.HeatingCoilSensDemand = 0.0;
+                furnace.CoolingCoilSensDemand = 0.0;
+                furnace.CoolingCoilLatentDemand = 0.0;
+                furnace.HeatingCoilSensDemand = 0.0;
             }
 
         } // End of the FirstHVACIteration control of the mass flow If block
 
         // Set the fan inlet node flow rates
-        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRateMaxAvail = thisFurnace.MdotFurnace;
-        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRateMaxAvail = furnace.MdotFurnace;
+        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
     }
 
     void CalcWaterToAirHeatPump(EnergyPlusData &state,
@@ -7823,7 +6704,7 @@ namespace Furnaces {
         Real64 HPCoilSensDemand;   // Heat pump sensible demand
         Real64 HPCoilSensCapacity; // Heat pump sensible capacity
 
-        Real64 SuppHeatCoilLoad; // Load passed to supplemental heater (W)
+        Real64 SuppCoilLoad; // Load passed to supplemental heater (W)
         Real64 CoolErrorToler;   // convergence tolerance used in cooling mode
         Real64 HeatErrorToler;   // convergence tolerance used in heating mode
         int SolFlag;             // flag returned from iteration routine to denote problems
@@ -7832,14 +6713,14 @@ namespace Furnaces {
         Real64 &TotalZoneSensLoad = state.dataFurnaces->TotalZoneSensLoad;
         Real64 &CoolPartLoadRatio = state.dataFurnaces->CoolPartLoadRatio;
         Real64 &HeatPartLoadRatio = state.dataFurnaces->HeatPartLoadRatio;
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
         // Set local variables
         Real64 Dummy2 = 0.0;            // used as dummy heat and reheat coil load
         Real64 OnOffAirFlowRatio = 1.0; // Ratio of compressor ON air mass flow to AVERAGE air mass flow over time step
-        int FurnaceInletNode = thisFurnace.FurnaceInletNodeNum;
-        HVAC::FanOp fanOp = thisFurnace.fanOp; // fan operating mode
-        thisFurnace.MdotFurnace = thisFurnace.DesignMassFlowRate;
+        int FurnaceInletNode = furnace.FurnaceInletNode;
+        HVAC::FanOp fanOp = furnace.fanOp; // fan operating mode
+        furnace.MdotFurnace = furnace.DesignMassFlowRate;
 
         //*********INITIAL CALCULATIONS****************
         // set the fan part load fraction
@@ -7867,22 +6748,22 @@ namespace Furnaces {
         // AND air flow rate is greater than zero...
         // AND the air system has a cooling load and is not set back or in the deadband...
         // OR the system is controlled by a humidistat and there is a latent load
-        if ((thisFurnace.availSched->getCurrentVal() > 0.0 && state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate > 0.0) &&
-            ((state.dataFurnaces->CoolingLoad) || (thisFurnace.Humidistat && thisFurnace.CoolingCoilLatentDemand < 0.0))) {
+        if ((furnace.availSched->getCurrentVal() > 0.0 && state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate > 0.0) &&
+            ((state.dataFurnaces->CoolingLoad) || (furnace.Humidistat && furnace.CoolingCoilLatentDemand < 0.0))) {
 
             // Set the air flow rate to the design flow rate and set the fan operation fraction to 1 (continuous operation)
-            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.DesignMassFlowRate;
+            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.DesignMassFlowRate;
             state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; // see 'Note' under INITIAL CALCULATIONS
 
             //         !Set the operation flag to run the fan continuously
             //         fanOp = FanOp::Continuous
 
             // Set the input parameters for CalcFurnaceOutput
-            thisFurnace.HeatingCoilSensDemand = 0.0;
-            thisFurnace.CoolingCoilLatentDemand = 0.0;
-            thisFurnace.CoolingCoilSensDemand = 0.0;
-            thisFurnace.CompPartLoadRatio = 0.0; // compressor off
-            thisFurnace.InitHeatPump = true;     // initialization call to Calc Furnace
+            furnace.HeatingCoilSensDemand = 0.0;
+            furnace.CoolingCoilLatentDemand = 0.0;
+            furnace.CoolingCoilSensDemand = 0.0;
+            furnace.CompPartLoadRatio = 0.0; // compressor off
+            furnace.InitHeatPump = true;     // initialization call to Calc Furnace
             CoolPartLoadRatio = 0.0;
 
             // Get no load result in order to calculate the effect of the fan and the mixed air equipment
@@ -7901,8 +6782,8 @@ namespace Furnaces {
                               false);
 
             // Set the input parameters for CalcFurnaceOutput
-            thisFurnace.CoolingCoilSensDemand = 1.0;
-            thisFurnace.CompPartLoadRatio = 1.0; // compressor ON
+            furnace.CoolingCoilSensDemand = 1.0;
+            furnace.CompPartLoadRatio = 1.0; // compressor ON
             CoolPartLoadRatio = 1.0;
 
             // Get full load result in order to estimate the operating part load ratio for continuous fan operation
@@ -7939,17 +6820,17 @@ namespace Furnaces {
                 CoolPartLoadRatio = max(MinPLR, min(1.0, std::abs(HPCoilSensDemand) / std::abs(HPCoilSensCapacity)));
             }
 
-            thisFurnace.InitHeatPump = false;
+            furnace.InitHeatPump = false;
 
             // check bounds on sensible output prior to iteration using RegulaFalsi
             if (ZoneSensLoadMetFanONCompON > TotalZoneSensLoad) {
                 CoolPartLoadRatio = 1.0;
                 HPCoilSensDemand = std::abs(ZoneSensLoadMetFanONCompON - ZoneSensLoadMetFanONCompOFF);
-                thisFurnace.CoolingCoilSensDemand = HPCoilSensDemand;
+                furnace.CoolingCoilSensDemand = HPCoilSensDemand;
             } else if (ZoneSensLoadMetFanONCompOFF < TotalZoneSensLoad) {
                 CoolPartLoadRatio = 0.0;
-                thisFurnace.CompPartLoadRatio = 0.0; // compressor OFF
-                thisFurnace.CoolingCoilSensDemand = 0.0;
+                furnace.CompPartLoadRatio = 0.0; // compressor OFF
+                furnace.CoolingCoilSensDemand = 0.0;
                 CalcFurnaceOutput(state,
                                   FurnaceNum,
                                   FirstHVACIteration,
@@ -7965,7 +6846,7 @@ namespace Furnaces {
                                   false);
             } else {
                 //         Calculate the sensible part load ratio through iteration
-                CoolErrorToler = thisFurnace.CoolingConvergenceTolerance;
+                CoolErrorToler = furnace.CoolingConvergenceTolerance;
                 SolFlag = 0; // # of iterations if positive, -1 means failed to converge, -2 means bounds are incorrect
                 // CoolErrorToler is in fraction of load, MaxIter = 600, SolFalg = # of iterations or error as appropriate
                 auto f = [&state, FurnaceNum, FirstHVACIteration, fanOp, compressorOp, TotalZoneSensLoad, ZoneSensLoadMetFanONCompOFF](
@@ -7999,11 +6880,11 @@ namespace Furnaces {
                                       OnOffAirFlowRatio,
                                       false);
                     if (std::abs(ZoneSensLoadMet - TotalZoneSensLoad) / TotalZoneSensLoad > CoolErrorToler) {
-                        if (thisFurnace.SensibleMaxIterIndex == 0) {
+                        if (furnace.SensibleMaxIterIndex == 0) {
                             ShowWarningMessage(state,
                                                format("Cooling coil control failed to converge for {}:{}",
-                                                      HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                      thisFurnace.Name));
+                                                      HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                      furnace.Name));
                             ShowContinueError(state, "  Iteration limit exceeded in calculating DX cooling coil sensible part-load ratio.");
                             ShowContinueErrorTimeStamp(state,
                                                        format("Sensible load to be met by DX coil = {:.2T} (watts), sensible output of DX coil = "
@@ -8015,9 +6896,9 @@ namespace Furnaces {
                             state,
                             format("{} \"{}\" - Iteration limit exceeded in calculating sensible cooling part-load ratio error "
                                    "continues. Sensible load statistics:",
-                                   HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                   thisFurnace.Name),
-                            thisFurnace.SensibleMaxIterIndex,
+                                   HVAC::unitarySysTypeNames[(int)furnace.type],
+                                   furnace.Name),
+                            furnace.SensibleMaxIterIndex,
                             TotalZoneSensLoad,
                             TotalZoneSensLoad);
                     }
@@ -8038,10 +6919,10 @@ namespace Furnaces {
                                       OnOffAirFlowRatio,
                                       false);
                     if ((ZoneSensLoadMet - TotalZoneSensLoad) / TotalZoneSensLoad > CoolErrorToler) {
-                        if (thisFurnace.SensibleRegulaFalsiFailedIndex == 0) {
+                        if (furnace.SensibleRegulaFalsiFailedIndex == 0) {
                             ShowWarningMessage(
                                 state,
-                                format("Cooling coil control failed for {}:{}", HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name));
+                                format("Cooling coil control failed for {}:{}", HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name));
                             ShowContinueError(state, "  Cooling sensible part-load ratio determined to be outside the range of 0-1.");
                             ShowContinueError(
                                 state,
@@ -8053,9 +6934,9 @@ namespace Furnaces {
                         ShowRecurringWarningErrorAtEnd(
                             state,
                             format("{} \"{}\" - Cooling sensible part-load ratio out of range error continues. Sensible cooling load statistics:",
-                                   HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                   thisFurnace.Name),
-                            thisFurnace.SensibleRegulaFalsiFailedIndex,
+                                   HVAC::unitarySysTypeNames[(int)furnace.type],
+                                   furnace.Name),
+                            furnace.SensibleRegulaFalsiFailedIndex,
                             TotalZoneSensLoad,
                             TotalZoneSensLoad);
                     }
@@ -8063,27 +6944,27 @@ namespace Furnaces {
             }
 
             if (fanOp == HVAC::FanOp::Cycling) {
-                thisFurnace.MdotFurnace *= CoolPartLoadRatio;
+                furnace.MdotFurnace *= CoolPartLoadRatio;
             }
 
             //*********HEATING CALCULATIONS****************
             // If Furnace runs with a heating load then set HeatCoilLoad on Heating Coil and the Mass Flow
-        } else if ((thisFurnace.availSched->getCurrentVal() > 0.0) && (state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate > 0.0) &&
+        } else if ((furnace.availSched->getCurrentVal() > 0.0) && (state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate > 0.0) &&
                    state.dataFurnaces->HeatingLoad) {
 
             // Set the air flow rate to the design flow rate and set the fan operation fraction to 1 (continuous operation)
-            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.DesignMassFlowRate;
+            state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.DesignMassFlowRate;
             state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; // see 'Note' under INITIAL CALCULATIONS
 
             //         !Set the operation flag to run the fan continuously
             //         fanOp = FanOp::Continuous
 
             // Set the input parameters for CalcFurnaceOutput
-            thisFurnace.HeatingCoilSensDemand = 0.0;
-            thisFurnace.CoolingCoilLatentDemand = 0.0;
-            thisFurnace.CoolingCoilSensDemand = 0.0;
-            thisFurnace.CompPartLoadRatio = 0.0; // compressor off
-            thisFurnace.InitHeatPump = true;     // initialization call to Calc Furnace
+            furnace.HeatingCoilSensDemand = 0.0;
+            furnace.CoolingCoilLatentDemand = 0.0;
+            furnace.CoolingCoilSensDemand = 0.0;
+            furnace.CompPartLoadRatio = 0.0; // compressor off
+            furnace.InitHeatPump = true;     // initialization call to Calc Furnace
             HeatPartLoadRatio = 0.0;
 
             // Get no load result in order to calculate the effect of the fan and the mixed air equipment
@@ -8102,8 +6983,8 @@ namespace Furnaces {
                               false);
 
             // Set the input parameters for CalcFurnaceOutput
-            thisFurnace.HeatingCoilSensDemand = 1.0;
-            thisFurnace.CompPartLoadRatio = 1.0; // compressor ON
+            furnace.HeatingCoilSensDemand = 1.0;
+            furnace.CompPartLoadRatio = 1.0; // compressor ON
             HeatPartLoadRatio = 1.0;
 
             // Get full load result in order to estimate the operating part load ratio for continuous fan operation
@@ -8141,18 +7022,18 @@ namespace Furnaces {
                 HeatPartLoadRatio = max(MinPLR, min(1.0, std::abs(HPCoilSensDemand) / std::abs(HPCoilSensCapacity)));
             }
 
-            thisFurnace.InitHeatPump = false;
+            furnace.InitHeatPump = false;
 
             // check bounds on sensible output prior to iteration using RegulaFalsi
             if (ZoneSensLoadMetFanONCompON < TotalZoneSensLoad) {
                 HeatPartLoadRatio = 1.0;
                 ZoneSensLoadMet = ZoneSensLoadMetFanONCompON;
                 HPCoilSensDemand = std::abs(ZoneSensLoadMetFanONCompON - ZoneSensLoadMetFanONCompOFF);
-                thisFurnace.HeatingCoilSensDemand = HPCoilSensDemand;
+                furnace.HeatingCoilSensDemand = HPCoilSensDemand;
             } else if (ZoneSensLoadMetFanONCompOFF > TotalZoneSensLoad) {
                 HeatPartLoadRatio = 0.0;
                 ZoneSensLoadMet = ZoneSensLoadMetFanONCompOFF;
-                thisFurnace.CompPartLoadRatio = 0.0; // compressor ON
+                furnace.CompPartLoadRatio = 0.0; // compressor ON
                 CalcFurnaceOutput(state,
                                   FurnaceNum,
                                   FirstHVACIteration,
@@ -8168,7 +7049,7 @@ namespace Furnaces {
                                   false);
             } else {
                 //         Calculate the sensible part load ratio through iteration
-                HeatErrorToler = thisFurnace.HeatingConvergenceTolerance;
+                HeatErrorToler = furnace.HeatingConvergenceTolerance;
                 SolFlag = 0; // # of iterations if positive, -1 means failed to converge, -2 means bounds are incorrect
                 // HeatErrorToler is in fraction of load, MaxIter = 600, SolFalg = # of iterations or error as appropriate
                 auto f = [&state, FurnaceNum, FirstHVACIteration, fanOp, compressorOp, TotalZoneSensLoad, ZoneSensLoadMetFanONCompOFF](
@@ -8202,11 +7083,11 @@ namespace Furnaces {
                                   false);
                 if (SolFlag == -1 && !state.dataGlobal->WarmupFlag && !FirstHVACIteration) {
                     if (std::abs(ZoneSensLoadMet - TotalZoneSensLoad) / TotalZoneSensLoad > HeatErrorToler) {
-                        if (thisFurnace.WSHPHeatMaxIterIndex == 0) {
+                        if (furnace.WSHPHeatMaxIterIndex == 0) {
                             ShowWarningMessage(state,
                                                format("Heating coil control failed to converge for {}:{}",
-                                                      HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                      thisFurnace.Name));
+                                                      HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                      furnace.Name));
                             ShowContinueError(state, "  Iteration limit exceeded in calculating DX heating coil sensible part-load ratio.");
                             ShowContinueErrorTimeStamp(state,
                                                        format("Sensible load to be met by DX coil = {:.2T} (watts), sensible output of DX coil = "
@@ -8217,9 +7098,9 @@ namespace Furnaces {
                         ShowRecurringWarningErrorAtEnd(
                             state,
                             format("{} \"{}\" - Iteration limit exceeded in calculating sensible heating part-load ratio error continues.",
-                                   HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                   thisFurnace.Name),
-                            thisFurnace.WSHPHeatMaxIterIndex,
+                                   HVAC::unitarySysTypeNames[(int)furnace.type],
+                                   furnace.Name),
+                            furnace.WSHPHeatMaxIterIndex,
                             TotalZoneSensLoad,
                             TotalZoneSensLoad);
                     }
@@ -8239,10 +7120,10 @@ namespace Furnaces {
                                       OnOffAirFlowRatio,
                                       false);
                     if ((ZoneSensLoadMet - TotalZoneSensLoad) / TotalZoneSensLoad > HeatErrorToler) {
-                        if (thisFurnace.WSHPHeatRegulaFalsiFailedIndex == 0) {
+                        if (furnace.WSHPHeatRegulaFalsiFailedIndex == 0) {
                             ShowWarningError(
                                 state,
-                                format("Heating coil control failed for {}:{}", HVAC::unitarySysTypeNames[(int)thisFurnace.type], thisFurnace.Name));
+                                format("Heating coil control failed for {}:{}", HVAC::unitarySysTypeNames[(int)furnace.type], furnace.Name));
                             ShowContinueError(state, "  Heating sensible part-load ratio determined to be outside the range of 0-1.");
                             ShowContinueError(
                                 state,
@@ -8253,9 +7134,9 @@ namespace Furnaces {
                         }
                         ShowRecurringWarningErrorAtEnd(state,
                                                        format("{} \"{}\" - Heating sensible part-load ratio out of range error continues.",
-                                                              HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                              thisFurnace.Name),
-                                                       thisFurnace.WSHPHeatRegulaFalsiFailedIndex,
+                                                              HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                              furnace.Name),
+                                                       furnace.WSHPHeatRegulaFalsiFailedIndex,
                                                        TotalZoneSensLoad,
                                                        TotalZoneSensLoad);
                     }
@@ -8264,7 +7145,7 @@ namespace Furnaces {
 
             //       CALL supplemental heater if required
             if ((TotalZoneSensLoad - ZoneSensLoadMet) > HVAC::SmallLoad && HeatPartLoadRatio >= 1.0) {
-                SuppHeatCoilLoad = TotalZoneSensLoad - ZoneSensLoadMet;
+                SuppCoilLoad = TotalZoneSensLoad - ZoneSensLoadMet;
                 CalcFurnaceOutput(state,
                                   FurnaceNum,
                                   FirstHVACIteration,
@@ -8272,7 +7153,7 @@ namespace Furnaces {
                                   compressorOp,
                                   CoolPartLoadRatio,
                                   HeatPartLoadRatio,
-                                  SuppHeatCoilLoad,
+                                  SuppCoilLoad,
                                   Dummy2,
                                   ZoneSensLoadMet,
                                   ZoneLatLoadMet,
@@ -8281,22 +7162,22 @@ namespace Furnaces {
             }
 
             if (fanOp == HVAC::FanOp::Cycling) {
-                thisFurnace.MdotFurnace *= HeatPartLoadRatio;
+                furnace.MdotFurnace *= HeatPartLoadRatio;
             }
 
             //**********HVAC Scheduled ON, but no cooling, dehumidification or heating load*********
-        } else if (thisFurnace.availSched->getCurrentVal() > 0.0) {
-            thisFurnace.InitHeatPump = true; // initialization call to Calc Furnace
+        } else if (furnace.availSched->getCurrentVal() > 0.0) {
+            furnace.InitHeatPump = true; // initialization call to Calc Furnace
             HeatPartLoadRatio = 0.0;
             CoolPartLoadRatio = 0.0;
             state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; //! see 'Note' under INITIAL CALCULATIONS
             // set report variables
-            thisFurnace.CompPartLoadRatio = 0.0;
-            thisFurnace.CoolingCoilSensDemand = 0.0;
-            thisFurnace.CoolingCoilLatentDemand = 0.0;
-            thisFurnace.HeatingCoilSensDemand = 0.0;
+            furnace.CompPartLoadRatio = 0.0;
+            furnace.CoolingCoilSensDemand = 0.0;
+            furnace.CoolingCoilLatentDemand = 0.0;
+            furnace.HeatingCoilSensDemand = 0.0;
             if (fanOp == HVAC::FanOp::Cycling) {
-                thisFurnace.MdotFurnace = 0.0;
+                furnace.MdotFurnace = 0.0;
                 state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; // see 'Note' under INITIAL CALCULATIONS
                 CalcFurnaceOutput(state,
                                   FurnaceNum,
@@ -8311,7 +7192,7 @@ namespace Furnaces {
                                   ZoneLatLoadMet,
                                   OnOffAirFlowRatio,
                                   false);
-                thisFurnace.MdotFurnace = 0.0;
+                furnace.MdotFurnace = 0.0;
             } else { // continuous fan, cycling coil
                 CalcFurnaceOutput(state,
                                   FurnaceNum,
@@ -8329,15 +7210,15 @@ namespace Furnaces {
             }
             //*********No heating or cooling or dehumidification*********
         } else {
-            thisFurnace.InitHeatPump = true; // initialization call to Calc Furnace
-            thisFurnace.MdotFurnace = 0.0;
+            furnace.InitHeatPump = true; // initialization call to Calc Furnace
+            furnace.MdotFurnace = 0.0;
             HeatPartLoadRatio = 0.0;
             CoolPartLoadRatio = 0.0;
             state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0; // see 'Note' under INITIAL CALCULATIONS
-            thisFurnace.CompPartLoadRatio = 0.0;
-            thisFurnace.CoolingCoilSensDemand = 0.0;
-            thisFurnace.CoolingCoilLatentDemand = 0.0;
-            thisFurnace.HeatingCoilSensDemand = 0.0;
+            furnace.CompPartLoadRatio = 0.0;
+            furnace.CoolingCoilSensDemand = 0.0;
+            furnace.CoolingCoilLatentDemand = 0.0;
+            furnace.HeatingCoilSensDemand = 0.0;
             CalcFurnaceOutput(state,
                               FurnaceNum,
                               FirstHVACIteration,
@@ -8351,12 +7232,12 @@ namespace Furnaces {
                               ZoneLatLoadMet,
                               OnOffAirFlowRatio,
                               false);
-            thisFurnace.MdotFurnace = 0.0;
+            furnace.MdotFurnace = 0.0;
         }
 
         // Set the fan inlet node flow rates
-        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRateMaxAvail = thisFurnace.MdotFurnace;
-        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = thisFurnace.MdotFurnace;
+        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRateMaxAvail = furnace.MdotFurnace;
+        state.dataLoopNodes->Node(FurnaceInletNode).MassFlowRate = furnace.MdotFurnace;
     }
 
     void CalcFurnaceOutput(EnergyPlusData &state,
@@ -8390,9 +7271,8 @@ namespace Furnaces {
         // Simulate each child object in the correct order for each system type. This routine is used in the
         // RegulaFalsi function CALL. Air mass flow rate is set each iteration based on PLR.
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-        auto &inletNode = state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum);
-        int CoolingCoilType_Num = thisFurnace.CoolingCoilType_Num;
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+        auto &inletNode = state.dataLoopNodes->Node(furnace.FurnaceInletNode);
         Real64 QActual = 0.0; // heating coil load met or delivered
         state.dataFurnaces->ModifiedHeatCoilLoad = 0.0;
 
@@ -8407,23 +7287,23 @@ namespace Furnaces {
             if (state.dataFurnaces->CoolHeatPLRRat < 1.0) {
                 if (state.dataFurnaces->CoolHeatPLRRat > 0.0) {
                     inletNode.MassFlowRate = state.dataFurnaces->CompOnMassFlow * CoolPartLoadRatio / state.dataFurnaces->CoolHeatPLRRat;
-                    if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+                    if (furnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
                         SetAverageAirFlow(state, FurnaceNum, CoolPartLoadRatio / state.dataFurnaces->CoolHeatPLRRat, OnOffAirFlowRatio);
                     }
                 } else {
                     inletNode.MassFlowRate = state.dataFurnaces->CompOnMassFlow * CoolPartLoadRatio;
-                    if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+                    if (furnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
                         SetAverageAirFlow(state, FurnaceNum, max(HeatPartLoadRatio, CoolPartLoadRatio), OnOffAirFlowRatio);
                     }
                 }
             } else {
                 inletNode.MassFlowRate = state.dataFurnaces->CompOnMassFlow * max(HeatPartLoadRatio, CoolPartLoadRatio);
-                if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+                if (furnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
                     SetAverageAirFlow(state, FurnaceNum, max(HeatPartLoadRatio, CoolPartLoadRatio), OnOffAirFlowRatio);
                 }
             }
         } else {
-            if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+            if (furnace.type != HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
                 SetAverageAirFlow(state, FurnaceNum, max(HeatPartLoadRatio, CoolPartLoadRatio), OnOffAirFlowRatio);
             }
         }
@@ -8431,17 +7311,17 @@ namespace Furnaces {
         inletNode.MassFlowRateMaxAvail = inletNode.MassFlowRate;
 
         // Simulate the air-to-air heat pump
-        if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
+        if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
             //   Simulate blow-thru fan and non-linear coils twice to update PLF used by the ONOFF Fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
-                if (CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
                                                                         BlankString,
                                                                         FirstHVACIteration,
                                                                         compressorOp,
                                                                         CoolPartLoadRatio,
-                                                                        thisFurnace.CoolingCoilIndex,
+                                                                        furnace.CoolCoilNum,
                                                                         fanOp,
                                                                         HXUnitOn,
                                                                         OnOffAirFlowRatio,
@@ -8451,39 +7331,39 @@ namespace Furnaces {
                                        BlankString,
                                        compressorOp,
                                        FirstHVACIteration,
-                                       thisFurnace.CoolingCoilIndex,
+                                       furnace.CoolCoilNum,
                                        fanOp,
                                        CoolPartLoadRatio,
                                        OnOffAirFlowRatio);
                 }
                 DXCoils::SimDXCoil(
-                    state, BlankString, compressorOp, FirstHVACIteration, thisFurnace.HeatingCoilIndex, fanOp, HeatPartLoadRatio, OnOffAirFlowRatio);
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                    state, BlankString, compressorOp, FirstHVACIteration, furnace.HeatCoilNum, fanOp, HeatPartLoadRatio, OnOffAirFlowRatio);
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
             //   Simulate cooling and heating coils
-            if (CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
+            if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                HXAssistCoil::SimHXAssistedCoolingCoil(state,
                                                                     BlankString,
                                                                     FirstHVACIteration,
                                                                     compressorOp,
                                                                     CoolPartLoadRatio,
-                                                                    thisFurnace.CoolingCoilIndex,
+                                                                    furnace.CoolCoilNum,
                                                                     fanOp,
                                                                     HXUnitOn,
                                                                     OnOffAirFlowRatio,
                                                                     state.dataFurnaces->EconomizerFlag);
             } else {
                 DXCoils::SimDXCoil(
-                    state, BlankString, compressorOp, FirstHVACIteration, thisFurnace.CoolingCoilIndex, fanOp, CoolPartLoadRatio, OnOffAirFlowRatio);
+                    state, BlankString, compressorOp, FirstHVACIteration, furnace.CoolCoilNum, fanOp, CoolPartLoadRatio, OnOffAirFlowRatio);
             }
             DXCoils::SimDXCoil(
-                state, BlankString, compressorOp, FirstHVACIteration, thisFurnace.HeatingCoilIndex, fanOp, HeatPartLoadRatio, OnOffAirFlowRatio);
+                state, BlankString, compressorOp, FirstHVACIteration, furnace.HeatCoilNum, fanOp, HeatPartLoadRatio, OnOffAirFlowRatio);
             //   Simulate the draw-thru fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::DrawThru) {
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            if (furnace.fanPlace == HVAC::FanPlace::DrawThru) {
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
             //   Simulate the supplemental heating coil
-            if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
+            if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
                 bool SuppHeatingCoilFlag = true;
                 CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual);
             } else {
@@ -8492,16 +7372,16 @@ namespace Furnaces {
                 CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual);
             }
             // Simulate the parameter estimate water-to-air heat pump
-        } else if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && thisFurnace.WatertoAirHPType == WAHPCoilType::Simple) {
+        } else if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && furnace.WatertoAirHPType == WAHPCoilType::Simple) {
             //    Simulate blow-thru fan and non-linear coils twice to update PLF used by the ONOFF Fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 // COIL:WATERTOAIRHPSIMPLE:COOLING
                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
                                                                 BlankString,
-                                                                thisFurnace.CoolingCoilIndex,
-                                                                thisFurnace.CoolingCoilSensDemand,
-                                                                thisFurnace.CoolingCoilLatentDemand,
+                                                                furnace.CoolCoilNum,
+                                                                furnace.CoolingCoilSensDemand,
+                                                                furnace.CoolingCoilLatentDemand,
                                                                 fanOp,
                                                                 compressorOp,
                                                                 CoolPartLoadRatio,
@@ -8510,23 +7390,23 @@ namespace Furnaces {
                 // COIL:WATERTOAIRHPSIMPLE:HEATING
                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
                                                                 BlankString,
-                                                                thisFurnace.HeatingCoilIndex,
-                                                                thisFurnace.HeatingCoilSensDemand,
+                                                                furnace.HeatCoilNum,
+                                                                furnace.HeatingCoilSensDemand,
                                                                 Dummy,
                                                                 fanOp,
                                                                 compressorOp,
                                                                 HeatPartLoadRatio,
                                                                 FirstHVACIteration); // HeatPartLoadRatio
                 //      Simulate the whole thing a second time so that the correct PLF required by the coils is used by the Fan. *******
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
             //    Simulate the cooling and heating coils
             // COIL:WATERTOAIRHPSIMPLE:COOLING
             WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
                                                             BlankString,
-                                                            thisFurnace.CoolingCoilIndex,
-                                                            thisFurnace.CoolingCoilSensDemand,
-                                                            thisFurnace.CoolingCoilLatentDemand,
+                                                            furnace.CoolCoilNum,
+                                                            furnace.CoolingCoilSensDemand,
+                                                            furnace.CoolingCoilLatentDemand,
                                                             fanOp,
                                                             compressorOp,
                                                             CoolPartLoadRatio,
@@ -8535,19 +7415,19 @@ namespace Furnaces {
             // COIL:WATERTOAIRHPSIMPLE:HEATING
             WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
                                                             BlankString,
-                                                            thisFurnace.HeatingCoilIndex,
-                                                            thisFurnace.HeatingCoilSensDemand,
+                                                            furnace.HeatCoilNum,
+                                                            furnace.HeatingCoilSensDemand,
                                                             Dummy,
                                                             fanOp,
                                                             compressorOp,
                                                             HeatPartLoadRatio,
                                                             FirstHVACIteration); // HeatPartLoadRatio
             //     Simulate the draw-thru fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
             //     Simulate the supplemental heating coil
-            if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
+            if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat && ReheatCoilLoad > 0.0) {
                 bool SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
                 CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual);
             } else {
@@ -8555,65 +7435,65 @@ namespace Furnaces {
                 CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
             }
             // Simulate the detailed water-to-air heat pump
-        } else if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && thisFurnace.WatertoAirHPType == WAHPCoilType::ParEst) {
+        } else if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir && furnace.WatertoAirHPType == WAHPCoilType::ParEst) {
             //    Simulate the draw-thru fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
             //    Simulate the cooling and heating coils
             WaterToAirHeatPump::SimWatertoAirHP(state,
                                                 BlankString,
-                                                thisFurnace.CoolingCoilIndex,
-                                                thisFurnace.DesignMassFlowRate,
+                                                furnace.CoolCoilNum,
+                                                furnace.DesignMassFlowRate,
                                                 fanOp,
                                                 FirstHVACIteration,
-                                                thisFurnace.InitHeatPump,
-                                                thisFurnace.CoolingCoilSensDemand,
-                                                thisFurnace.CoolingCoilLatentDemand,
+                                                furnace.InitHeatPump,
+                                                furnace.CoolingCoilSensDemand,
+                                                furnace.CoolingCoilLatentDemand,
                                                 compressorOp,
                                                 CoolPartLoadRatio);
             Real64 Dummy = 0.0;
             WaterToAirHeatPump::SimWatertoAirHP(state,
                                                 BlankString,
-                                                thisFurnace.HeatingCoilIndex,
-                                                thisFurnace.DesignMassFlowRate,
+                                                furnace.HeatCoilNum,
+                                                furnace.DesignMassFlowRate,
                                                 fanOp,
                                                 FirstHVACIteration,
-                                                thisFurnace.InitHeatPump,
-                                                thisFurnace.HeatingCoilSensDemand,
+                                                furnace.InitHeatPump,
+                                                furnace.HeatingCoilSensDemand,
                                                 Dummy,
                                                 compressorOp,
                                                 HeatPartLoadRatio);
             //    Simulate the draw-thru fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::DrawThru) {
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            if (furnace.fanPlace == HVAC::FanPlace::DrawThru) {
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
             //    Simulate the supplemental heating coil
             HeatingCoils::SimulateHeatingCoilComponents(
-                state, BlankString, FirstHVACIteration, HeatCoilLoad, thisFurnace.SuppHeatCoilIndex, _, true, fanOp);
+                state, BlankString, FirstHVACIteration, HeatCoilLoad, furnace.SuppCoilNum, _, true, fanOp);
 
         } else { // ELSE it's not a heat pump
             //   Simulate blow-thru fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
+            if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
 
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
 
                 //     For non-linear coils, simulate coil to update PLF used by the ONOFF Fan
-                if (thisFurnace.fanType == HVAC::FanType::OnOff) {
-                    if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatOnly && thisFurnace.type != HVAC::UnitarySysType::Furnace_HeatOnly) {
+                if (furnace.fanType == HVAC::FanType::OnOff) {
+                    if (furnace.type != HVAC::UnitarySysType::Unitary_HeatOnly && furnace.type != HVAC::UnitarySysType::Furnace_HeatOnly) {
 
-                        if (!thisFurnace.CoolingCoilUpstream) {
+                        if (!furnace.CoolCoilUpstream) {
                             bool SuppHeatingCoilFlag = false; // if false simulates heating coil
                             CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
                         }
 
-                        if (CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                            HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
+                        if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                            HXAssistCoil::SimHXAssistedCoolingCoil(state,
                                                                                 BlankString,
                                                                                 FirstHVACIteration,
                                                                                 compressorOp,
                                                                                 CoolPartLoadRatio,
-                                                                                thisFurnace.CoolingCoilIndex,
+                                                                                furnace.CoolCoilNum,
                                                                                 fanOp,
                                                                                 HXUnitOn,
                                                                                 OnOffAirFlowRatio,
@@ -8623,7 +7503,7 @@ namespace Furnaces {
                                                BlankString,
                                                compressorOp,
                                                FirstHVACIteration,
-                                               thisFurnace.CoolingCoilIndex,
+                                               furnace.CoolCoilNum,
                                                fanOp,
                                                CoolPartLoadRatio,
                                                OnOffAirFlowRatio,
@@ -8631,30 +7511,30 @@ namespace Furnaces {
                         }
                     }
 
-                    if (thisFurnace.CoolingCoilUpstream) {
+                    if (furnace.CoolCoilUpstream) {
                         bool SuppHeatingCoilFlag = false; // if false simulates heating coil
                         CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
                     }
-                    state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+                    state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
                 } // Simple OnOff fan
 
             } // Blow thru fan
 
             //   Simulate the cooling and heating coils
-            if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatOnly && thisFurnace.type != HVAC::UnitarySysType::Furnace_HeatOnly) {
+            if (furnace.type != HVAC::UnitarySysType::Unitary_HeatOnly && furnace.type != HVAC::UnitarySysType::Furnace_HeatOnly) {
 
-                if (!thisFurnace.CoolingCoilUpstream) {
+                if (!furnace.CoolCoilUpstream) {
                     bool SuppHeatingCoilFlag = false; // if false simulates heating coil
                     CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
                 }
 
-                if (CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
+                if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
                                                                         BlankString,
                                                                         FirstHVACIteration,
                                                                         compressorOp,
                                                                         CoolPartLoadRatio,
-                                                                        thisFurnace.CoolingCoilIndex,
+                                                                        furnace.CoolCoilNum,
                                                                         fanOp,
                                                                         HXUnitOn,
                                                                         OnOffAirFlowRatio,
@@ -8664,7 +7544,7 @@ namespace Furnaces {
                                        BlankString,
                                        compressorOp,
                                        FirstHVACIteration,
-                                       thisFurnace.CoolingCoilIndex,
+                                       furnace.CoolCoilNum,
                                        fanOp,
                                        CoolPartLoadRatio,
                                        OnOffAirFlowRatio,
@@ -8672,28 +7552,28 @@ namespace Furnaces {
                 }
             }
 
-            if (thisFurnace.CoolingCoilUpstream) {
+            if (furnace.CoolCoilUpstream) {
                 bool SuppHeatingCoilFlag = false; // if false simulates heating coil
                 CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, fanOp, QActual);
             }
             //   Simulate the draw-thru fan
-            if (thisFurnace.fanPlace == HVAC::FanPlace::DrawThru) {
-                state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            if (furnace.fanPlace == HVAC::FanPlace::DrawThru) {
+                state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             }
-            if (thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat || thisFurnace.SuppHeatCoilIndex > 0) {
+            if (furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat || furnace.SuppCoilNum > 0) {
                 bool SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
                 CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, ReheatCoilLoad, fanOp, QActual);
             }
         } // IF(Furnace(FurnaceNum)%type == UnitarySys_HeatPump_AirToAir)THEN
 
         // Get mass flow rate after components are simulated
-        auto &outletNode = state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum);
+        auto &outletNode = state.dataLoopNodes->Node(furnace.FurnaceOutletNode);
         Real64 AirMassFlow = inletNode.MassFlowRate; // this should be outlet node as in 9897?
 
         // check the DesignMaxOutletTemp and reset if necessary (for Coil:Gas:Heating or Coil:Electric:Heating only)
-        if (outletNode.Temp > thisFurnace.DesignMaxOutletTemp) {
+        if (outletNode.Temp > furnace.DesignMaxOutletTemp) {
             Real64 Wout = outletNode.HumRat;
-            Real64 Tout = thisFurnace.DesignMaxOutletTemp;
+            Real64 Tout = furnace.DesignMaxOutletTemp;
             state.dataFurnaces->ModifiedHeatCoilLoad = HeatCoilLoad - (AirMassFlow * Psychrometrics::PsyCpAirFnW(Wout) * (outletNode.Temp - Tout));
             outletNode.Temp = Tout;
         }
@@ -8707,20 +7587,20 @@ namespace Furnaces {
         CalcZoneSensibleLatentOutput(AirMassFlow,
                                      outletNode.Temp,
                                      outletNode.HumRat,
-                                     state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).Temp,
-                                     state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).HumRat,
+                                     state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).Temp,
+                                     state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).HumRat,
                                      SensibleOutput,
                                      LatentOutput,
                                      TotalOutput);
-        SensibleLoadMet = SensibleOutput - thisFurnace.SenLoadLoss;
-        thisFurnace.SensibleLoadMet = SensibleLoadMet;
+        SensibleLoadMet = SensibleOutput - furnace.SenLoadLoss;
+        furnace.SensibleLoadMet = SensibleLoadMet;
 
-        if (thisFurnace.Humidistat) {
-            LatentLoadMet = LatentOutput - thisFurnace.LatLoadLoss;
+        if (furnace.Humidistat) {
+            LatentLoadMet = LatentOutput - furnace.LatLoadLoss;
         } else {
             LatentLoadMet = 0.0;
         }
-        thisFurnace.LatentLoadMet = LatentLoadMet;
+        furnace.LatentLoadMet = LatentLoadMet;
     }
 
     //        End of Update subroutines for the Furnace Module
@@ -8767,6 +7647,8 @@ namespace Furnaces {
         //        Real64 par9_HXOnFlag = Par(9);
         //        Real64 par10_HeatingCoilPLR = Par(10);
 
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+        
         if (par6_loadFlag == 1.0) {
             CoolPartLoadRatio = PartLoadRatio;
             HeatPartLoadRatio = 0.0;
@@ -8775,18 +7657,17 @@ namespace Furnaces {
             CoolPartLoadRatio = 0.0;
             HeatPartLoadRatio = PartLoadRatio;
 
-            int const HeatingCoilType_Num(state.dataFurnaces->Furnace(FurnaceNum).HeatingCoilType_Num);
-            if (HeatingCoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel || HeatingCoilType_Num == HVAC::Coil_HeatingElectric ||
-                HeatingCoilType_Num == HVAC::Coil_HeatingWater || HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
-                HeatCoilLoad = state.dataFurnaces->Furnace(FurnaceNum).DesignHeatingCapacity * PartLoadRatio;
+            if (furnace.heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel || furnace.heatCoilType == HVAC::CoilType::HeatingElectric ||
+                furnace.heatCoilType == HVAC::CoilType::HeatingWater || furnace.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                HeatCoilLoad = furnace.DesignHeatingCapacity * PartLoadRatio;
             } else {
                 HeatCoilLoad = 0.0;
             }
         }
 
         //  OnOffAirFlowRatio = Par(8)
-        if (state.dataFurnaces->Furnace(FurnaceNum).type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
-            state.dataFurnaces->Furnace(FurnaceNum).CompPartLoadRatio = PartLoadRatio;
+        if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir) {
+            furnace.CompPartLoadRatio = PartLoadRatio;
         }
 
         if (par9_HXOnFlag == 1.0) {
@@ -8799,7 +7680,7 @@ namespace Furnaces {
             //    Par(10) = Furnace(FurnaceNum)%HeatPartLoadRatio
             //    FanOp = CycFan and Furnace(FurnaceNum)%HeatPartLoadRatio must be > 0 for Part(10) to be greater than 0
             //    This variable used when in heating mode and dehumidification (cooling) is required.
-            CoolingHeatingPLRRatio = min(1.0, CoolPartLoadRatio / state.dataFurnaces->Furnace(FurnaceNum).HeatPartLoadRatio);
+            CoolingHeatingPLRRatio = min(1.0, CoolPartLoadRatio / furnace.HeatPartLoadRatio);
         } else {
             CoolingHeatingPLRRatio = 1.0;
         }
@@ -8880,20 +7761,23 @@ namespace Furnaces {
         //        Real64 par9_HXUnitOne = Par[8];
 
         int CoilIndex;
+
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+        
         if (par6_loadTypeFlag == 1.0) {
             CoolPartLoadRatio = PartLoadRatio;
             HeatPartLoadRatio = 0.0;
             HeatCoilLoad = 0.0;
-            CoilIndex = state.dataFurnaces->Furnace(FurnaceNum).CoolingCoilIndex;
+            CoilIndex = furnace.CoolCoilNum;
         } else {
             CoolPartLoadRatio = 0.0;
             HeatPartLoadRatio = PartLoadRatio;
-            CoilIndex = state.dataFurnaces->Furnace(FurnaceNum).HeatingCoilIndex;
+            CoilIndex = furnace.HeatCoilNum;
         }
 
         // Get child component RuntimeFrac
         Real64 RuntimeFrac;
-        switch (state.dataFurnaces->Furnace(FurnaceNum).WatertoAirHPType) {
+        switch (furnace.WatertoAirHPType) {
         case WAHPCoilType::Simple: {
             RuntimeFrac = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(CoilIndex).RunFrac;
             break;
@@ -8912,7 +7796,7 @@ namespace Furnaces {
 
         state.dataFurnaces->OnOffFanPartLoadFractionSave = state.dataHVACGlobal->OnOffFanPartLoadFraction;
         // update fan and compressor run times
-        state.dataFurnaces->Furnace(FurnaceNum).CompPartLoadRatio = PartLoadRatio;
+        furnace.CompPartLoadRatio = PartLoadRatio;
 
         // Calculate the heating coil demand as (the zone sensible load - load met by fan heat and mixed air)
         // Note; The load met by fan heat and mixed air is calculated as mdot(zoneinletenthalpy-zoneoutletenthalpy)
@@ -8926,13 +7810,13 @@ namespace Furnaces {
         HPCoilSensDemand = LoadToBeMet - RuntimeFrac * ZoneSensLoadMetFanONCompOFF;
         //  HPCoilSensDemand = LoadToBeMet  - PartLoadRatio*ZoneSensLoadMetFanONCompOFF
         if (par6_loadTypeFlag == 1.0) {
-            state.dataFurnaces->Furnace(FurnaceNum).HeatingCoilSensDemand = 0.0;
-            state.dataFurnaces->Furnace(FurnaceNum).CoolingCoilSensDemand = std::abs(HPCoilSensDemand);
+            furnace.HeatingCoilSensDemand = 0.0;
+            furnace.CoolingCoilSensDemand = std::abs(HPCoilSensDemand);
         } else {
-            state.dataFurnaces->Furnace(FurnaceNum).HeatingCoilSensDemand = HPCoilSensDemand;
-            state.dataFurnaces->Furnace(FurnaceNum).CoolingCoilSensDemand = 0.0;
+            furnace.HeatingCoilSensDemand = HPCoilSensDemand;
+            furnace.CoolingCoilSensDemand = 0.0;
         }
-        state.dataFurnaces->Furnace(FurnaceNum).InitHeatPump = false; // initialization call to Calc Furnace
+        furnace.InitHeatPump = false; // initialization call to Calc Furnace
 
         // Calculate the zone loads met and the new part load ratio and for the specified run time
         Dummy = 0.0;
@@ -8986,8 +7870,8 @@ namespace Furnaces {
         // METHODOLOGY EMPLOYED:
         // The air flow rate in cooling, heating, and no cooling or heating can be different.
         // Calculate the air flow rate based on initializations made in InitFurnace.
-
-        int InletNode = state.dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum;
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+        int InletNode = furnace.FurnaceInletNode;
         Real64 AverageUnitMassFlow =
             (PartLoadRatio * state.dataFurnaces->CompOnMassFlow) + ((1 - PartLoadRatio) * state.dataFurnaces->CompOffMassFlow);
         if (state.dataFurnaces->CompOffFlowRatio > 0.0) {
@@ -8996,10 +7880,9 @@ namespace Furnaces {
         } else {
             state.dataFurnaces->FanSpeedRatio = state.dataFurnaces->CompOnFlowRatio;
         }
-
         // IF the furnace is scheduled on or nightime cycle overrides fan schedule. Uses same logic as fan.
-        if (state.dataFurnaces->Furnace(FurnaceNum).availSched->getCurrentVal() > 0.0 &&
-            ((state.dataFurnaces->Furnace(FurnaceNum).fanAvailSched->getCurrentVal() > 0.0 || state.dataHVACGlobal->TurnFansOn) &&
+        if (furnace.availSched->getCurrentVal() > 0.0 &&
+            ((furnace.fanAvailSched->getCurrentVal() > 0.0 || state.dataHVACGlobal->TurnFansOn) &&
              !state.dataHVACGlobal->TurnFansOff)) {
             state.dataLoopNodes->Node(InletNode).MassFlowRate = AverageUnitMassFlow;
             state.dataLoopNodes->Node(InletNode).MassFlowRateMaxAvail = AverageUnitMassFlow;
@@ -9013,7 +7896,7 @@ namespace Furnaces {
             OnOffAirFlowRatio = 1.0;
         }
 
-        state.dataFurnaces->Furnace(FurnaceNum).MdotFurnace = state.dataFurnaces->CompOnMassFlow;
+        furnace.MdotFurnace = state.dataFurnaces->CompOnMassFlow;
         state.dataFurnaces->OnOffAirFlowRatioSave = OnOffAirFlowRatio;
     }
 
@@ -9037,14 +7920,14 @@ namespace Furnaces {
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         Real64 ratio;
         Real64 OnOffRatio;
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
         // Report the Furnace Fan Part Load Ratio
-        if (thisFurnace.NumOfSpeedCooling < 1) {
-            if (thisFurnace.DesignMassFlowRate > 0.0) {
-                thisFurnace.FanPartLoadRatio = thisFurnace.MdotFurnace / thisFurnace.DesignMassFlowRate;
+        if (furnace.NumOfSpeedCooling < 1) {
+            if (furnace.DesignMassFlowRate > 0.0) {
+                furnace.FanPartLoadRatio = furnace.MdotFurnace / furnace.DesignMassFlowRate;
             } else {
-                thisFurnace.FanPartLoadRatio = 0.0;
+                furnace.FanPartLoadRatio = 0.0;
             }
         }
 
@@ -9052,29 +7935,29 @@ namespace Furnaces {
         if (state.afn->distribution_simulated) {
             state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopSystemOnMassFlowrate = state.dataFurnaces->CompOnMassFlow;
             state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopSystemOffMassFlowrate = state.dataFurnaces->CompOffMassFlow;
-            state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopFanOperationMode = thisFurnace.fanOp;
-            state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio = thisFurnace.FanPartLoadRatio;
+            state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopFanOperationMode = furnace.fanOp;
+            state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio = furnace.FanPartLoadRatio;
             OnOffRatio = state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio;
-            if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
+            if (furnace.type == HVAC::UnitarySysType::Unitary_HeatPump_AirToAir) {
                 state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio =
-                    max(thisFurnace.FanPartLoadRatio, thisFurnace.HeatPartLoadRatio, thisFurnace.CoolPartLoadRatio);
+                    max(furnace.FanPartLoadRatio, furnace.HeatPartLoadRatio, furnace.CoolPartLoadRatio);
                 state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio =
                     min(1.0, state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio);
             }
-            if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool) {
-                if (thisFurnace.HeatPartLoadRatio == 0.0 && thisFurnace.CoolPartLoadRatio == 0.0 && thisFurnace.FanPartLoadRatio > 0.0) {
-                    if (state.dataFurnaces->CompOnMassFlow < max(thisFurnace.MaxCoolAirMassFlow, thisFurnace.MaxHeatAirMassFlow) &&
+            if (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool) {
+                if (furnace.HeatPartLoadRatio == 0.0 && furnace.CoolPartLoadRatio == 0.0 && furnace.FanPartLoadRatio > 0.0) {
+                    if (state.dataFurnaces->CompOnMassFlow < max(furnace.MaxCoolAirMassFlow, furnace.MaxHeatAirMassFlow) &&
                         state.dataFurnaces->CompOnMassFlow > 0.0) {
-                        ratio = max(thisFurnace.MaxCoolAirMassFlow, thisFurnace.MaxHeatAirMassFlow) / state.dataFurnaces->CompOnMassFlow;
+                        ratio = max(furnace.MaxCoolAirMassFlow, furnace.MaxHeatAirMassFlow) / state.dataFurnaces->CompOnMassFlow;
                         state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio =
                             state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopOnOffFanPartLoadRatio * ratio;
                     }
                 }
             }
         }
-        if (thisFurnace.FirstPass) {
+        if (furnace.FirstPass) {
             if (!state.dataGlobal->SysSizingCalc) {
-                DataSizing::resetHVACSizingGlobals(state, 0, state.dataSize->CurSysNum, thisFurnace.FirstPass);
+                DataSizing::resetHVACSizingGlobals(state, 0, state.dataSize->CurSysNum, furnace.FirstPass);
             }
         }
         state.dataHVACGlobal->OnOffFanPartLoadFraction =
@@ -9106,54 +7989,55 @@ namespace Furnaces {
         int constexpr SolveMaxIter(50);
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
+        std::string HeatCoilName;
         Real64 mdot;              // heating coil steam or hot water mass flow rate
         Real64 MinWaterFlow;      // coil minimum hot water mass flow rate, kg/s
         Real64 MaxHotWaterFlow;   // coil maximum hot water mass flow rate, kg/s
         Real64 HotWaterMdot;      // actual hot water mass flow rate
-        int CoilTypeNum(0);       // heating coil type number
-        int HeatingCoilIndex(0);  // heating coil index
+        HVAC::CoilType coilType;       // heating coil type number
+        int HeatCoilNum(0);  // heating coil index
         int CoilControlNode(0);   // control node for hot water and steam heating coils
         int CoilOutletNode(0);    // air outlet node of the heating coils
         PlantLocation plantLoc{}; // plant loop location
 
         Real64 QActual = 0.0;                                               // actual heating load
-        std::string &HeatingCoilName = state.dataFurnaces->HeatingCoilName; // name of heating coil
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
         if (SuppHeatingCoilFlag) {
-            HeatingCoilName = thisFurnace.SuppHeatCoilName;
-            HeatingCoilIndex = thisFurnace.SuppHeatCoilIndex;
-            CoilControlNode = thisFurnace.SuppCoilControlNode;
-            CoilOutletNode = thisFurnace.SuppCoilOutletNode;
-            CoilTypeNum = thisFurnace.SuppHeatCoilType_Num;
-            plantLoc = thisFurnace.SuppPlantLoc;
-            MaxHotWaterFlow = thisFurnace.MaxSuppCoilFluidFlow;
+            HeatCoilName = furnace.SuppCoilName;
+            HeatCoilNum = furnace.SuppCoilNum;
+            CoilControlNode = furnace.SuppCoilControlNode;
+            CoilOutletNode = furnace.SuppCoilOutletNode;
+            coilType = furnace.suppHeatCoilType;
+            plantLoc = furnace.SuppPlantLoc;
+            MaxHotWaterFlow = furnace.MaxSuppCoilFluidFlow;
         } else {
-            HeatingCoilName = thisFurnace.HeatingCoilName;
-            HeatingCoilIndex = thisFurnace.HeatingCoilIndex;
-            CoilControlNode = thisFurnace.CoilControlNode;
-            CoilOutletNode = thisFurnace.CoilOutletNode;
-            CoilTypeNum = thisFurnace.HeatingCoilType_Num;
-            plantLoc = thisFurnace.plantLoc;
-            MaxHotWaterFlow = thisFurnace.MaxHeatCoilFluidFlow;
+            HeatCoilName = furnace.HeatCoilName;
+            HeatCoilNum = furnace.HeatCoilNum;
+            CoilControlNode = furnace.HeatCoilControlNode;
+            CoilOutletNode = furnace.CoilOutletNode;
+            coilType = furnace.heatCoilType;
+            plantLoc = furnace.plantLoc;
+            MaxHotWaterFlow = furnace.MaxHeatCoilFluidFlow;
         }
 
-        switch (CoilTypeNum) {
-        case HVAC::Coil_HeatingGasOrOtherFuel:
-        case HVAC::Coil_HeatingElectric:
-        case HVAC::Coil_HeatingDesuperheater: {
+        switch (coilType) {
+        case HVAC::CoilType::HeatingGasOrOtherFuel:
+        case HVAC::CoilType::HeatingElectric:
+        case HVAC::CoilType::HeatingDesuperheater: {
             HeatingCoils::SimulateHeatingCoilComponents(
-                state, HeatingCoilName, FirstHVACIteration, QCoilLoad, HeatingCoilIndex, QActual, SuppHeatingCoilFlag, fanOp);
+                state, HeatCoilName, FirstHVACIteration, QCoilLoad, HeatCoilNum, QActual, SuppHeatingCoilFlag, fanOp);
         } break;
-        case HVAC::Coil_HeatingWater: {
+        case HVAC::CoilType::HeatingWater: {
             if (QCoilLoad > HVAC::SmallLoad) {
                 PlantUtilities::SetComponentFlowRate(state, MaxHotWaterFlow, CoilControlNode, CoilOutletNode, plantLoc);
-                WaterCoils::SimulateWaterCoilComponents(state, HeatingCoilName, FirstHVACIteration, HeatingCoilIndex, QActual, fanOp);
+                WaterCoils::SimulateWaterCoilComponents(state, HeatCoilName, FirstHVACIteration, HeatCoilNum, QActual, fanOp);
 
                 if (QActual > (QCoilLoad + HVAC::SmallLoad)) {
                     // control water flow to obtain output matching QCoilLoad
                     MinWaterFlow = 0.0;
                     auto f = [&state, FurnaceNum, FirstHVACIteration, QCoilLoad, SuppHeatingCoilFlag](Real64 const HWFlow) {
+                        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
                         Real64 QCoilRequested = QCoilLoad;
 
                         // FUNCTION LOCAL VARIABLE DECLARATIONS:
@@ -9163,40 +8047,40 @@ namespace Furnaces {
                         if (!SuppHeatingCoilFlag) {
                             PlantUtilities::SetComponentFlowRate(state,
                                                                  mdot,
-                                                                 state.dataFurnaces->Furnace(FurnaceNum).CoilControlNode,
-                                                                 state.dataFurnaces->Furnace(FurnaceNum).CoilOutletNode,
-                                                                 state.dataFurnaces->Furnace(FurnaceNum).plantLoc);
+                                                                 furnace.HeatCoilControlNode,
+                                                                 furnace.CoilOutletNode,
+                                                                 furnace.plantLoc);
                             WaterCoils::SimulateWaterCoilComponents(state,
-                                                                    state.dataFurnaces->Furnace(FurnaceNum).HeatingCoilName,
+                                                                    furnace.HeatCoilName,
                                                                     FirstHVACIteration,
-                                                                    state.dataFurnaces->Furnace(FurnaceNum).HeatingCoilIndex,
+                                                                    furnace.HeatCoilNum,
                                                                     QCoilActual,
-                                                                    state.dataFurnaces->Furnace(FurnaceNum).fanOp);
+                                                                    furnace.fanOp);
                         } else {
                             // supplemental coil
                             PlantUtilities::SetComponentFlowRate(state,
                                                                  mdot,
-                                                                 state.dataFurnaces->Furnace(FurnaceNum).SuppCoilControlNode,
-                                                                 state.dataFurnaces->Furnace(FurnaceNum).SuppCoilOutletNode,
-                                                                 state.dataFurnaces->Furnace(FurnaceNum).SuppPlantLoc);
+                                                                 furnace.SuppCoilControlNode,
+                                                                 furnace.SuppCoilOutletNode,
+                                                                 furnace.SuppPlantLoc);
                             // simulate the hot water supplemental heating coil
                             WaterCoils::SimulateWaterCoilComponents(state,
-                                                                    state.dataFurnaces->Furnace(FurnaceNum).SuppHeatCoilName,
+                                                                    furnace.SuppCoilName,
                                                                     FirstHVACIteration,
-                                                                    state.dataFurnaces->Furnace(FurnaceNum).SuppHeatCoilIndex,
+                                                                    furnace.SuppCoilNum,
                                                                     QCoilActual,
-                                                                    state.dataFurnaces->Furnace(FurnaceNum).fanOp);
+                                                                    furnace.fanOp);
                         }
                         return QCoilRequested != 0.0 ? (QCoilActual - QCoilRequested) / QCoilRequested : 0.0;
                     };
                     int SolFlag = 0;
                     General::SolveRoot(state, ErrTolerance, SolveMaxIter, SolFlag, HotWaterMdot, f, MinWaterFlow, MaxHotWaterFlow);
                     if (SolFlag == -1) {
-                        if (thisFurnace.HotWaterCoilMaxIterIndex == 0) {
+                        if (furnace.HotWaterCoilMaxIterIndex == 0) {
                             ShowWarningMessage(state,
                                                format("CalcNonDXHeatingCoils: Hot water coil control failed for {}=\"{}\"",
-                                                      HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                      thisFurnace.Name));
+                                                      HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                      furnace.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, format("  Iteration limit [{}] exceeded in calculating hot water mass flow rate", SolveMaxIter));
                         }
@@ -9204,15 +8088,15 @@ namespace Furnaces {
                             state,
                             format("CalcNonDXHeatingCoils: Hot water coil control failed (iteration limit [{}]) for {}=\"{}",
                                    SolveMaxIter,
-                                   HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                   thisFurnace.Name),
-                            thisFurnace.HotWaterCoilMaxIterIndex);
+                                   HVAC::unitarySysTypeNames[(int)furnace.type],
+                                   furnace.Name),
+                            furnace.HotWaterCoilMaxIterIndex);
                     } else if (SolFlag == -2) {
-                        if (thisFurnace.HotWaterCoilMaxIterIndex2 == 0) {
+                        if (furnace.HotWaterCoilMaxIterIndex2 == 0) {
                             ShowWarningMessage(state,
                                                format("CalcNonDXHeatingCoils: Hot water coil control failed (maximum flow limits) for {}=\"{}\"",
-                                                      HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                      thisFurnace.Name));
+                                                      HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                      furnace.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, "...Bad hot water maximum flow rate limits");
                             ShowContinueError(state, format("...Given minimum water flow rate={:.3R} kg/s", MinWaterFlow));
@@ -9220,9 +8104,9 @@ namespace Furnaces {
                         }
                         ShowRecurringWarningErrorAtEnd(state,
                                                        format("CalcNonDXHeatingCoils: Hot water coil control failed (flow limits) for {}=\"{}\"",
-                                                              HVAC::unitarySysTypeNames[(int)thisFurnace.type],
-                                                              thisFurnace.Name),
-                                                       thisFurnace.HotWaterCoilMaxIterIndex2,
+                                                              HVAC::unitarySysTypeNames[(int)furnace.type],
+                                                              furnace.Name),
+                                                       furnace.HotWaterCoilMaxIterIndex2,
                                                        MaxHotWaterFlow,
                                                        MinWaterFlow,
                                                        _,
@@ -9235,18 +8119,18 @@ namespace Furnaces {
                 PlantUtilities::SetComponentFlowRate(state, mdot, CoilControlNode, CoilOutletNode, plantLoc);
             }
             // simulate the hot water heating coil
-            WaterCoils::SimulateWaterCoilComponents(state, HeatingCoilName, FirstHVACIteration, HeatingCoilIndex, QActual, fanOp);
+            WaterCoils::SimulateWaterCoilComponents(state, HeatCoilName, FirstHVACIteration, HeatCoilNum, QActual, fanOp);
         } break;
-        case HVAC::Coil_HeatingSteam: {
+        case HVAC::CoilType::HeatingSteam: {
             if (QCoilLoad > HVAC::SmallLoad) {
                 PlantUtilities::SetComponentFlowRate(state, MaxHotWaterFlow, CoilControlNode, CoilOutletNode, plantLoc);
                 // simulate the steam heating coil
-                SteamCoils::SimulateSteamCoilComponents(state, HeatingCoilName, FirstHVACIteration, HeatingCoilIndex, QCoilLoad, QActual, fanOp);
+                SteamCoils::SimulateSteamCoilComponents(state, HeatCoilName, FirstHVACIteration, HeatCoilNum, QCoilLoad, QActual, fanOp);
             } else {
                 mdot = 0.0;
                 PlantUtilities::SetComponentFlowRate(state, mdot, CoilControlNode, CoilOutletNode, plantLoc);
                 // simulate the steam heating coil
-                SteamCoils::SimulateSteamCoilComponents(state, HeatingCoilName, FirstHVACIteration, HeatingCoilIndex, QCoilLoad, QActual, fanOp);
+                SteamCoils::SimulateSteamCoilComponents(state, HeatCoilName, FirstHVACIteration, HeatCoilNum, QCoilLoad, QActual, fanOp);
             }
         } break;
         default:
@@ -9305,33 +8189,33 @@ namespace Furnaces {
         Real64 SystemSensibleLoad = QZnReq; // Positive value means heating required
         Real64 TotalZoneSensibleLoad = QZnReq;
         Real64 TotalZoneLatentLoad = QLatReq;
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
         // initialize local variables
         bool UnitOn = true;
-        int OutletNode = thisFurnace.FurnaceOutletNodeNum;
-        int InletNode = thisFurnace.FurnaceInletNodeNum;
-        Real64 AirMassFlow = thisFurnace.DesignMassFlowRate;
-        HVAC::FanOp fanOp = thisFurnace.fanOp; // fan operating mode
-        int ZoneNum = thisFurnace.ControlZoneNum;
+        int OutletNode = furnace.FurnaceOutletNode;
+        int InletNode = furnace.FurnaceInletNode;
+        Real64 AirMassFlow = furnace.DesignMassFlowRate;
+        HVAC::FanOp fanOp = furnace.fanOp; // fan operating mode
+        int ZoneNum = furnace.ControlZoneNum;
 
         // Set latent load for heating
         if (state.dataFurnaces->HeatingLoad) {
-            thisFurnace.HeatCoolMode = Furnaces::ModeOfOperation::HeatingMode;
+            furnace.HeatCoolMode = Furnaces::ModeOfOperation::HeatingMode;
             // Set latent load for cooling and no sensible load condition
         } else if (state.dataFurnaces->CoolingLoad) {
-            thisFurnace.HeatCoolMode = Furnaces::ModeOfOperation::CoolingMode;
+            furnace.HeatCoolMode = Furnaces::ModeOfOperation::CoolingMode;
         } else {
-            thisFurnace.HeatCoolMode = Furnaces::ModeOfOperation::NoCoolHeat;
+            furnace.HeatCoolMode = Furnaces::ModeOfOperation::NoCoolHeat;
         }
 
         // set the on/off flags
-        if (thisFurnace.fanOp == HVAC::FanOp::Cycling) {
+        if (furnace.fanOp == HVAC::FanOp::Cycling) {
             // cycling unit only runs if there is a cooling or heating load.
             if (std::abs(QZnReq) < HVAC::SmallLoad || AirMassFlow < HVAC::SmallMassFlow ||
                 state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
                 UnitOn = false;
             }
-        } else if (thisFurnace.fanOp == HVAC::FanOp::Continuous) {
+        } else if (furnace.fanOp == HVAC::FanOp::Continuous) {
             // continuous unit: fan runs if scheduled on; coil runs only if there is a cooling or heating load
             if (AirMassFlow < HVAC::SmallMassFlow) {
                 UnitOn = false;
@@ -9343,10 +8227,10 @@ namespace Furnaces {
 
         Real64 SaveMassFlowRate = state.dataLoopNodes->Node(InletNode).MassFlowRate;
         // decide current working mode for IHP
-        if ((FirstHVACIteration) && (thisFurnace.bIsIHP))
-            IntegratedHeatPump::DecideWorkMode(state, thisFurnace.CoolingCoilIndex, TotalZoneSensibleLoad, TotalZoneLatentLoad);
+        if ((FirstHVACIteration) && (furnace.isIHP))
+            IntegratedHeatPump::DecideWorkMode(state, furnace.ihpNum, TotalZoneSensibleLoad, TotalZoneLatentLoad);
 
-        if (!FirstHVACIteration && thisFurnace.fanOp == HVAC::FanOp::Cycling &&
+        if (!FirstHVACIteration && furnace.fanOp == HVAC::FanOp::Cycling &&
             (QZnReq < (-1.0 * HVAC::SmallLoad) || TotalZoneLatentLoad < (-HVAC::SmallLoad)) && EconoActive) {
             // for cycling fan, cooling load, check whether furnace can meet load with compressor off
             compressorOp = HVAC::CompressorOp::Off;
@@ -9366,7 +8250,7 @@ namespace Furnaces {
             TotalZoneSensibleLoad = QZnReq;
             TotalZoneLatentLoad = QLatReq;
 
-            if (SpeedNum == thisFurnace.NumOfSpeedCooling && SpeedRatio == 1.0) {
+            if (SpeedNum == furnace.NumOfSpeedCooling && SpeedRatio == 1.0) {
                 // compressor on (reset inlet air mass flow rate to starting value)
                 state.dataLoopNodes->Node(InletNode).MassFlowRate = SaveMassFlowRate;
                 compressorOp = HVAC::CompressorOp::On;
@@ -9401,7 +8285,7 @@ namespace Furnaces {
                               SupHeaterLoad);
         }
 
-        if (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool) {
+        if (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool) {
             state.dataFurnaces->SaveCompressorPLR = PartLoadFrac;
         } else {
             if (SpeedNum > 1) {
@@ -9417,8 +8301,8 @@ namespace Furnaces {
         TotalZoneSensibleLoad = QZnReq;
         TotalZoneLatentLoad = QLatReq;
         //     Calculate the reheat coil output
-        if ((thisFurnace.availSched->getCurrentVal() > 0.0) &&
-            (thisFurnace.Humidistat && thisFurnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat &&
+        if ((furnace.availSched->getCurrentVal() > 0.0) &&
+            (furnace.Humidistat && furnace.DehumidControlType_Num == DehumidificationControlMode::CoolReheat &&
              (QLatReq < 0.0))) { // if a Humidistat is installed and dehumidification control type is CoolReheat
             CalcVarSpeedHeatPump(state,
                                  FurnaceNum,
@@ -9433,24 +8317,24 @@ namespace Furnaces {
                                  TotalZoneLatentLoad,
                                  OnOffAirFlowRatio,
                                  ReheatCoilLoad);
-            if (thisFurnace.ZoneSequenceHeatingNum > 0) {
-                QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum)
-                                    .SequencedOutputRequiredToHeatingSP(thisFurnace.ZoneSequenceHeatingNum) /
-                                thisFurnace.ControlZoneMassFlowFrac);
+            if (furnace.ZoneSequenceHeatingNum > 0) {
+                QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum)
+                                    .SequencedOutputRequiredToHeatingSP(furnace.ZoneSequenceHeatingNum) /
+                                furnace.ControlZoneMassFlowFrac);
             } else {
-                QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(thisFurnace.ControlZoneNum).OutputRequiredToHeatingSP /
-                                thisFurnace.ControlZoneMassFlowFrac);
+                QToHeatSetPt = (state.dataZoneEnergyDemand->ZoneSysEnergyDemand(furnace.ControlZoneNum).OutputRequiredToHeatingSP /
+                                furnace.ControlZoneMassFlowFrac);
             }
             //       Cooling mode or floating condition and dehumidification is required
             if (QToHeatSetPt < 0.0) {
                 //         Calculate the reheat coil load wrt the heating setpoint temperature. Reheat coil picks up
                 //         the entire excess sensible cooling (DX cooling coil and impact of outdoor air).
                 ReheatCoilLoad = max(0.0, (QToHeatSetPt - ActualSensibleOutput));
-                thisFurnace.DehumidInducedHeatingDemandRate = ReheatCoilLoad;
+                furnace.DehumidInducedHeatingDemandRate = ReheatCoilLoad;
                 //       Heating mode and dehumidification is required
             } else {
                 ReheatCoilLoad = max(QToHeatSetPt, QToHeatSetPt - ActualSensibleOutput);
-                thisFurnace.DehumidInducedHeatingDemandRate = max(0.0, ActualSensibleOutput * (-1.0));
+                furnace.DehumidInducedHeatingDemandRate = max(0.0, ActualSensibleOutput * (-1.0));
             }
 
             SupHeaterLoad = 0.0;
@@ -9514,10 +8398,10 @@ namespace Furnaces {
         // calculate delivered capacity
         AirMassFlow = state.dataLoopNodes->Node(InletNode).MassFlowRate;
 
-        thisFurnace.MdotFurnace = AirMassFlow;
+        furnace.MdotFurnace = AirMassFlow;
 
         QTotUnitOut =
-            AirMassFlow * (state.dataLoopNodes->Node(OutletNode).Enthalpy - state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone).Enthalpy);
+            AirMassFlow * (state.dataLoopNodes->Node(OutletNode).Enthalpy - state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone).Enthalpy);
 
         state.dataLoopNodes->Node(InletNode).MassFlowRateMaxAvail = AirMassFlow;
         state.dataLoopNodes->Node(OutletNode).MassFlowRateMaxAvail = AirMassFlow;
@@ -9541,34 +8425,34 @@ namespace Furnaces {
         }
 
         // report variables
-        thisFurnace.DehumidInducedHeatingDemandRate = ReheatCoilLoad;
+        furnace.DehumidInducedHeatingDemandRate = ReheatCoilLoad;
         if (QZnReq > HVAC::SmallLoad) { // HEATING LOAD
-            thisFurnace.CoolingCoilSensDemand = 0.0;
-            thisFurnace.HeatingCoilSensDemand = QZnReq;
+            furnace.CoolingCoilSensDemand = 0.0;
+            furnace.HeatingCoilSensDemand = QZnReq;
         } else {
-            thisFurnace.CoolingCoilSensDemand = std::abs(QZnReq);
-            thisFurnace.HeatingCoilSensDemand = 0.0;
+            furnace.CoolingCoilSensDemand = std::abs(QZnReq);
+            furnace.HeatingCoilSensDemand = 0.0;
         }
 
-        thisFurnace.CompPartLoadRatio = state.dataFurnaces->SaveCompressorPLR;
-        if (thisFurnace.fanOp == HVAC::FanOp::Cycling) {
+        furnace.CompPartLoadRatio = state.dataFurnaces->SaveCompressorPLR;
+        if (furnace.fanOp == HVAC::FanOp::Cycling) {
             if (SupHeaterLoad > 0.0) {
-                thisFurnace.FanPartLoadRatio = 1.0;
+                furnace.FanPartLoadRatio = 1.0;
             } else {
                 if (SpeedNum < 2) {
-                    thisFurnace.FanPartLoadRatio = PartLoadFrac;
+                    furnace.FanPartLoadRatio = PartLoadFrac;
                 } else {
-                    thisFurnace.FanPartLoadRatio = 1.0;
+                    furnace.FanPartLoadRatio = 1.0;
                 }
             }
         } else {
             if (UnitOn) {
-                thisFurnace.FanPartLoadRatio = 1.0;
+                furnace.FanPartLoadRatio = 1.0;
             } else {
                 if (SpeedNum < 2) {
-                    thisFurnace.FanPartLoadRatio = PartLoadFrac;
+                    furnace.FanPartLoadRatio = PartLoadFrac;
                 } else {
-                    thisFurnace.FanPartLoadRatio = 1.0;
+                    furnace.FanPartLoadRatio = 1.0;
                 }
             }
         }
@@ -9622,8 +8506,9 @@ namespace Furnaces {
         Real64 noLatOutput = 0.0;
         Real64 ErrorToler = 0.001; // Error tolerance for convergence from input deck
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
-        if (thisFurnace.availSched->getCurrentVal() == 0.0) return;
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
+
+        if (furnace.availSched->getCurrentVal() == 0.0) return;
 
         // Get result when DX coil is off
         SupHeaterLoad = 0.0;
@@ -9641,8 +8526,8 @@ namespace Furnaces {
                              OnOffAirFlowRatio,
                              SupHeaterLoad);
 
-        if (thisFurnace.bIsIHP) {
-            IHPMode = IntegratedHeatPump::GetCurWorkMode(state, thisFurnace.CoolingCoilIndex);
+        if (furnace.isIHP) {
+            IHPMode = IntegratedHeatPump::GetCurWorkMode(state, furnace.ihpNum);
             if ((IntegratedHeatPump::IHPOperationMode::DedicatedWaterHtg == IHPMode) ||
                 (IntegratedHeatPump::IHPOperationMode::SCWHMatchWH == IHPMode)) { // cooling capacity is a resultant
                 return;
@@ -9664,18 +8549,18 @@ namespace Furnaces {
         // Get full load result
         PartLoadFrac = 1.0;
         SpeedRatio = 1.0;
-        if (thisFurnace.HeatCoolMode == Furnaces::ModeOfOperation::HeatingMode) {
-            SpeedNum = thisFurnace.NumOfSpeedHeating;
-        } else if (thisFurnace.HeatCoolMode == Furnaces::ModeOfOperation::CoolingMode) {
-            SpeedNum = thisFurnace.NumOfSpeedCooling;
+        if (furnace.HeatCoolMode == Furnaces::ModeOfOperation::HeatingMode) {
+            SpeedNum = furnace.NumOfSpeedHeating;
+        } else if (furnace.HeatCoolMode == Furnaces::ModeOfOperation::CoolingMode) {
+            SpeedNum = furnace.NumOfSpeedCooling;
         } else if (QLatReq < -HVAC::SmallLoad) {
-            SpeedNum = thisFurnace.NumOfSpeedCooling;
+            SpeedNum = furnace.NumOfSpeedCooling;
         } else {
             SpeedNum = 1;
             PartLoadFrac = 0.0;
         }
 
-        if (thisFurnace.bIsIHP) SpeedNum = IntegratedHeatPump::GetMaxSpeedNumIHP(state, thisFurnace.CoolingCoilIndex);
+        if (furnace.isIHP) SpeedNum = IntegratedHeatPump::GetMaxSpeedNumIHP(state, furnace.ihpNum);
 
         CalcVarSpeedHeatPump(state,
                              FurnaceNum,
@@ -9695,18 +8580,18 @@ namespace Furnaces {
             if (QLatReq <= LatOutput || (QZnReq < -HVAC::SmallLoad && QZnReq <= FullOutput) || (QZnReq > HVAC::SmallLoad && QZnReq >= FullOutput)) {
                 PartLoadFrac = 1.0;
                 SpeedRatio = 1.0;
-                thisFurnace.CompPartLoadRatio = PartLoadFrac;
-                thisFurnace.CompSpeedRatio = SpeedRatio;
-                thisFurnace.CompSpeedNum = SpeedNum;
+                furnace.CompPartLoadRatio = PartLoadFrac;
+                furnace.CompSpeedRatio = SpeedRatio;
+                furnace.CompSpeedNum = SpeedNum;
                 return;
             }
         } else if (QZnReq < -HVAC::SmallLoad) {
             if (QZnReq <= FullOutput) {
                 PartLoadFrac = 1.0;
                 SpeedRatio = 1.0;
-                thisFurnace.CompPartLoadRatio = PartLoadFrac;
-                thisFurnace.CompSpeedRatio = SpeedRatio;
-                thisFurnace.CompSpeedNum = SpeedNum;
+                furnace.CompPartLoadRatio = PartLoadFrac;
+                furnace.CompSpeedRatio = SpeedRatio;
+                furnace.CompSpeedNum = SpeedNum;
                 return;
             }
         } else {
@@ -9746,30 +8631,30 @@ namespace Furnaces {
                     General::SolveRoot(state, ErrorToler, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                     if (SolFla == -1) {
                         if (!state.dataGlobal->WarmupFlag) {
-                            if (thisFurnace.ErrCountCyc == 0) {
-                                ++thisFurnace.ErrCountCyc;
+                            if (furnace.ErrCountCyc == 0) {
+                                ++furnace.ErrCountCyc;
                                 ShowWarningError(
-                                    state, format("Iteration limit exceeded calculating VS WSHP unit cycling ratio, for unit={}", thisFurnace.Name));
+                                    state, format("Iteration limit exceeded calculating VS WSHP unit cycling ratio, for unit={}", furnace.Name));
                                 ShowContinueErrorTimeStamp(state, format("Cycling ratio returned={:.2R}", PartLoadFrac));
                             } else {
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
-                                    thisFurnace.Name + "\": Iteration limit warning exceeding calculating DX unit cycling ratio  continues...",
-                                    thisFurnace.ErrIndexCyc,
+                                    furnace.Name + "\": Iteration limit warning exceeding calculating DX unit cycling ratio  continues...",
+                                    furnace.ErrIndexCyc,
                                     PartLoadFrac,
                                     PartLoadFrac);
                             }
                         }
                     } else if (SolFla == -2) {
                         ShowFatalError(
-                            state, format("VS WSHP unit cycling ratio calculation failed: cycling limits exceeded, for unit={}", thisFurnace.Name));
+                            state, format("VS WSHP unit cycling ratio calculation failed: cycling limits exceeded, for unit={}", furnace.Name));
                     }
                 } else {
                     // Check to see which speed to meet the load
                     PartLoadFrac = 1.0;
                     SpeedRatio = 1.0;
                     if (QZnReq < -HVAC::SmallLoad) { // Cooling
-                        for (i = 2; i <= thisFurnace.NumOfSpeedCooling; ++i) {
+                        for (i = 2; i <= furnace.NumOfSpeedCooling; ++i) {
                             CalcVarSpeedHeatPump(state,
                                                  FurnaceNum,
                                                  FirstHVACIteration,
@@ -9790,7 +8675,7 @@ namespace Furnaces {
                             }
                         }
                     } else {
-                        for (i = 2; i <= thisFurnace.NumOfSpeedHeating; ++i) {
+                        for (i = 2; i <= furnace.NumOfSpeedHeating; ++i) {
                             CalcVarSpeedHeatPump(state,
                                                  FurnaceNum,
                                                  FirstHVACIteration,
@@ -9818,23 +8703,23 @@ namespace Furnaces {
                     General::SolveRoot(state, ErrorToler, MaxIte, SolFla, SpeedRatio, f, 1.0e-10, 1.0);
                     if (SolFla == -1) {
                         if (!state.dataGlobal->WarmupFlag) {
-                            if (thisFurnace.ErrCountVar == 0) {
-                                ++thisFurnace.ErrCountVar;
+                            if (furnace.ErrCountVar == 0) {
+                                ++furnace.ErrCountVar;
                                 ShowWarningError(
-                                    state, format("Iteration limit exceeded calculating VS WSHP unit speed ratio, for unit={}", thisFurnace.Name));
+                                    state, format("Iteration limit exceeded calculating VS WSHP unit speed ratio, for unit={}", furnace.Name));
                                 ShowContinueErrorTimeStamp(state, format("Speed ratio returned=[{:.2R}], Speed number ={}", SpeedRatio, SpeedNum));
                             } else {
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
-                                    thisFurnace.Name + "\": Iteration limit warning exceeding calculating DX unit speed ratio continues...",
-                                    thisFurnace.ErrIndexVar,
+                                    furnace.Name + "\": Iteration limit warning exceeding calculating DX unit speed ratio continues...",
+                                    furnace.ErrIndexVar,
                                     SpeedRatio,
                                     SpeedRatio);
                             }
                         }
                     } else if (SolFla == -2) {
                         ShowFatalError(
-                            state, format("VS WSHP unit compressor speed calculation failed: speed limits exceeded, for unit={}", thisFurnace.Name));
+                            state, format("VS WSHP unit compressor speed calculation failed: speed limits exceeded, for unit={}", furnace.Name));
                     }
                 }
             } else {
@@ -9849,7 +8734,7 @@ namespace Furnaces {
         if (QLatReq < -HVAC::SmallLoad && QLatReq < LatOutput) {
             PartLoadFrac = 1.0;
             SpeedRatio = 1.0;
-            for (i = SpeedNum; i <= thisFurnace.NumOfSpeedCooling; ++i) {
+            for (i = SpeedNum; i <= furnace.NumOfSpeedCooling; ++i) {
                 CalcVarSpeedHeatPump(state,
                                      FurnaceNum,
                                      FirstHVACIteration,
@@ -9895,23 +8780,23 @@ namespace Furnaces {
                 }
                 if (SolFla == -1) {
                     if (!state.dataGlobal->WarmupFlag) {
-                        if (thisFurnace.ErrCountVar2 == 0) {
-                            ++thisFurnace.ErrCountVar2;
+                        if (furnace.ErrCountVar2 == 0) {
+                            ++furnace.ErrCountVar2;
                             ShowWarningError(state,
-                                             format("Iteration limit exceeded calculating VS WSHP unit speed ratio, for unit={}", thisFurnace.Name));
+                                             format("Iteration limit exceeded calculating VS WSHP unit speed ratio, for unit={}", furnace.Name));
                             ShowContinueErrorTimeStamp(state, format("Speed ratio returned=[{:.2R}], Speed number ={}", SpeedRatio, SpeedNum));
                         } else {
                             ShowRecurringWarningErrorAtEnd(state,
-                                                           thisFurnace.Name +
+                                                           furnace.Name +
                                                                "\": Iteration limit warning exceeding calculating DX unit speed ratio continues...",
-                                                           thisFurnace.ErrIndexVar,
+                                                           furnace.ErrIndexVar,
                                                            SpeedRatio,
                                                            SpeedRatio);
                         }
                     }
                 } else if (SolFla == -2) {
                     ShowFatalError(state,
-                                   format("VS WSHP unit compressor speed calculation failed: speed limits exceeded, for unit={}", thisFurnace.Name));
+                                   format("VS WSHP unit compressor speed calculation failed: speed limits exceeded, for unit={}", furnace.Name));
                 }
             }
         }
@@ -9920,13 +8805,13 @@ namespace Furnaces {
         // if the heating coil cannot meet the load, trim with supplemental heater
         // occurs with constant fan mode when compressor is on or off
         // occurs with cycling fan mode when compressor PLR is equal to 1
-        if ((QZnReq > HVAC::SmallLoad && QZnReq > FullOutput) && (thisFurnace.SuppHeatCoilIndex != 0)) {
+        if ((QZnReq > HVAC::SmallLoad && QZnReq > FullOutput) && (furnace.SuppCoilNum != 0)) {
             PartLoadFrac = 1.0;
             SpeedRatio = 1.0;
-            if (thisFurnace.NumOfSpeedHeating > 0)
-                SpeedNum = thisFurnace.NumOfSpeedHeating; // maximum heating speed, avoid zero for cooling only mode
+            if (furnace.NumOfSpeedHeating > 0)
+                SpeedNum = furnace.NumOfSpeedHeating; // maximum heating speed, avoid zero for cooling only mode
 
-            if (state.dataEnvrn->OutDryBulbTemp <= thisFurnace.MaxOATSuppHeat) {
+            if (state.dataEnvrn->OutDryBulbTemp <= furnace.MaxOATSuppHeat) {
                 SupHeaterLoad = QZnReq - FullOutput;
             } else {
                 SupHeaterLoad = 0.0;
@@ -9947,7 +8832,7 @@ namespace Furnaces {
         }
 
         // check the outlet of the supplemental heater to be lower than the maximum supplemental heater supply air temperature
-        if (state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).Temp > thisFurnace.DesignMaxOutletTemp && SupHeaterLoad > 0.0) {
+        if (state.dataLoopNodes->Node(furnace.FurnaceOutletNode).Temp > furnace.DesignMaxOutletTemp && SupHeaterLoad > 0.0) {
 
             //   If the supply air temperature is to high, turn off the supplemental heater to recalculate the outlet temperature
             CalcNonDXHeatingCoils(state, FurnaceNum, true, FirstHVACIteration, 0.0, fanOp, QCoilActual);
@@ -9955,10 +8840,10 @@ namespace Furnaces {
             //   the supplemental heater, otherwise leave the supplemental heater off. If the supplemental heater is to be turned on,
             //   use the outlet conditions when the supplemental heater was off (CALL above) as the inlet conditions for the calculation
             //   of supplemental heater load to just meet the maximum supply air temperature from the supplemental heater.
-            if (state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).Temp < thisFurnace.DesignMaxOutletTemp) {
-                Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).HumRat);
-                SupHeaterLoad = state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum).MassFlowRate * CpAir *
-                                (thisFurnace.DesignMaxOutletTemp - state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).Temp);
+            if (state.dataLoopNodes->Node(furnace.FurnaceOutletNode).Temp < furnace.DesignMaxOutletTemp) {
+                Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(furnace.FurnaceOutletNode).HumRat);
+                SupHeaterLoad = state.dataLoopNodes->Node(furnace.FurnaceInletNode).MassFlowRate * CpAir *
+                                (furnace.DesignMaxOutletTemp - state.dataLoopNodes->Node(furnace.FurnaceOutletNode).Temp);
 
             } else {
                 SupHeaterLoad = 0.0;
@@ -9966,15 +8851,15 @@ namespace Furnaces {
         }
 
         // prepare module level output
-        thisFurnace.CompPartLoadRatio = PartLoadFrac;
-        thisFurnace.CompSpeedRatio = SpeedRatio;
-        thisFurnace.CompSpeedNum = SpeedNum;
-        thisFurnace.CoolingCoilLatentDemand = std::abs(QLatReq);
+        furnace.CompPartLoadRatio = PartLoadFrac;
+        furnace.CompSpeedRatio = SpeedRatio;
+        furnace.CompSpeedNum = SpeedNum;
+        furnace.CoolingCoilLatentDemand = std::abs(QLatReq);
 
-        if (thisFurnace.fanOp == HVAC::FanOp::Continuous) {
-            thisFurnace.FanPartLoadRatio = 1.0;
+        if (furnace.fanOp == HVAC::FanOp::Continuous) {
+            furnace.FanPartLoadRatio = 1.0;
         } else {
-            thisFurnace.FanPartLoadRatio = PartLoadFrac;
+            furnace.FanPartLoadRatio = PartLoadFrac;
         }
     }
 
@@ -10012,39 +8897,39 @@ namespace Furnaces {
         // Set inlet air mass flow rate based on PLR and compressor on/off air flow rates
         SetVSHPAirFlow(state, FurnaceNum, PartLoadFrac, OnOffAirFlowRatio, SpeedNum, SpeedRatio);
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
-        if ((SupHeaterLoad > 1.0e-10) && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool) && (thisFurnace.SuppHeatCoilIndex == 0)) {
+        if ((SupHeaterLoad > 1.0e-10) && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool) && (furnace.SuppCoilNum == 0)) {
             // ONLY HEATING COIL, NO SUPPLEMENTAL COIL, USED FOR REHEAT DURING DUHMI
-            HeatCoilLoad = thisFurnace.DesignHeatingCapacity * PartLoadFrac; // REHEAT IN FAN ON TIME
+            HeatCoilLoad = furnace.DesignHeatingCapacity * PartLoadFrac; // REHEAT IN FAN ON TIME
 
             if (HeatCoilLoad > SupHeaterLoad) HeatCoilLoad = SupHeaterLoad; // HEATING COIL RUN TIME < FAN ON TIME
 
-        } else if ((QZnReq > HVAC::SmallLoad) && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
-            HeatCoilLoad = thisFurnace.DesignHeatingCapacity * PartLoadFrac;
+        } else if ((QZnReq > HVAC::SmallLoad) && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            HeatCoilLoad = furnace.DesignHeatingCapacity * PartLoadFrac;
         } else {
             HeatCoilLoad = 0.0;
         }
 
-        Real64 AirMassFlow = state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum).MassFlowRate;
+        Real64 AirMassFlow = state.dataLoopNodes->Node(furnace.FurnaceInletNode).MassFlowRate;
         // if blow through, simulate fan then coils
-        if (thisFurnace.fanPlace == HVAC::FanPlace::BlowThru) {
-            state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+        if (furnace.fanPlace == HVAC::FanPlace::BlowThru) {
+            state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
 
-            if ((!thisFurnace.CoolingCoilUpstream) && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            if ((!furnace.CoolCoilUpstream) && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
                 // simulate thisFurnace heating coil
                 bool SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, furnace.fanOp, QCoilActual);
             }
 
             if ((QZnReq < -HVAC::SmallLoad || (QLatReq < -HVAC::SmallLoad)) &&
-                (state.dataEnvrn->OutDryBulbTemp >= thisFurnace.MinOATCompressorCooling)) { // COOLING MODE or dehumidification mode
+                (state.dataEnvrn->OutDryBulbTemp >= furnace.MinOATCompressorCooling)) { // COOLING MODE or dehumidification mode
 
-                if (thisFurnace.bIsIHP) {
+                if (furnace.isIHP) {
                     IntegratedHeatPump::SimIHP(state,
                                                BlankString,
-                                               thisFurnace.CoolingCoilIndex,
-                                               thisFurnace.fanOp,
+                                               furnace.ihpNum,
+                                               furnace.fanOp,
                                                compressorOp,
                                                PartLoadFrac,
                                                SpeedNum,
@@ -10057,8 +8942,8 @@ namespace Furnaces {
                 } else {
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                               BlankString,
-                                                              thisFurnace.CoolingCoilIndex,
-                                                              thisFurnace.fanOp,
+                                                              furnace.CoolCoilNum,
+                                                              furnace.fanOp,
                                                               compressorOp,
                                                               PartLoadFrac,
                                                               SpeedNum,
@@ -10071,13 +8956,13 @@ namespace Furnaces {
                 SavePartloadRatio = PartLoadFrac;
                 SaveSpeedRatio = SpeedRatio;
 
-                state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.CoolingCoilIndex).PartLoadRatio;
+                state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.CoolCoilNum).PartLoadRatio;
             } else {
-                if (thisFurnace.bIsIHP) {
+                if (furnace.isIHP) {
                     IntegratedHeatPump::SimIHP(state,
                                                BlankString,
-                                               thisFurnace.CoolingCoilIndex,
-                                               thisFurnace.fanOp,
+                                               furnace.ihpNum,
+                                               furnace.fanOp,
                                                compressorOp,
                                                PartLoadFrac,
                                                SpeedNum,
@@ -10089,17 +8974,17 @@ namespace Furnaces {
                                                OnOffAirFlowRatio);
                 } else {
                     VariableSpeedCoils::SimVariableSpeedCoils(
-                        state, BlankString, thisFurnace.CoolingCoilIndex, thisFurnace.fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRatio);
+                        state, BlankString, furnace.CoolCoilNum, furnace.fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRatio);
                 }
             }
 
-            if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatCool) {
+            if (furnace.type != HVAC::UnitarySysType::Unitary_HeatCool) {
                 if ((QZnReq > HVAC::SmallLoad) && state.dataFurnaces->HeatingLoad) {
-                    if (thisFurnace.bIsIHP) {
+                    if (furnace.isIHP) {
                         IntegratedHeatPump::SimIHP(state,
                                                    BlankString,
-                                                   thisFurnace.HeatingCoilIndex,
-                                                   thisFurnace.fanOp,
+                                                   furnace.ihpNum,
+                                                   furnace.fanOp,
                                                    compressorOp,
                                                    PartLoadFrac,
                                                    SpeedNum,
@@ -10112,8 +8997,8 @@ namespace Furnaces {
                     } else {
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                                   BlankString,
-                                                                  thisFurnace.HeatingCoilIndex,
-                                                                  thisFurnace.fanOp,
+                                                                  furnace.HeatCoilNum,
+                                                                  furnace.fanOp,
                                                                   compressorOp,
                                                                   PartLoadFrac,
                                                                   SpeedNum,
@@ -10126,13 +9011,13 @@ namespace Furnaces {
                     SavePartloadRatio = PartLoadFrac;
                     SaveSpeedRatio = SpeedRatio;
 
-                    state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.HeatingCoilIndex).PartLoadRatio;
+                    state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.HeatCoilNum).PartLoadRatio;
                 } else {
-                    if (thisFurnace.bIsIHP) {
+                    if (furnace.isIHP) {
                         IntegratedHeatPump::SimIHP(state,
                                                    BlankString,
-                                                   thisFurnace.CoolingCoilIndex,
-                                                   thisFurnace.fanOp,
+                                                   furnace.ihpNum,
+                                                   furnace.fanOp,
                                                    compressorOp,
                                                    PartLoadFrac,
                                                    SpeedNum,
@@ -10145,8 +9030,8 @@ namespace Furnaces {
                     } else {
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                                   BlankString,
-                                                                  thisFurnace.HeatingCoilIndex,
-                                                                  thisFurnace.fanOp,
+                                                                  furnace.HeatCoilNum,
+                                                                  furnace.fanOp,
                                                                   compressorOp,
                                                                   0.0,
                                                                   1,
@@ -10156,29 +9041,29 @@ namespace Furnaces {
                                                                   OnOffAirFlowRatio);
                     }
                 }
-            } else if (thisFurnace.CoolingCoilUpstream && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            } else if (furnace.CoolCoilUpstream && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
                 // simulate thisFurnace heating coil
                 bool SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, furnace.fanOp, QCoilActual);
             }
 
             // Call twice to ensure the fan outlet conditions are updated
-            state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
 
-            if ((!thisFurnace.CoolingCoilUpstream) && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            if ((!furnace.CoolCoilUpstream) && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
                 // simulate thisFurnace heating coil
                 bool SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, furnace.fanOp, QCoilActual);
             }
 
             if ((QZnReq < -HVAC::SmallLoad || (QLatReq < -HVAC::SmallLoad)) &&
-                (state.dataEnvrn->OutDryBulbTemp >= thisFurnace.MinOATCompressorCooling)) {
+                (state.dataEnvrn->OutDryBulbTemp >= furnace.MinOATCompressorCooling)) {
 
-                if (thisFurnace.bIsIHP) {
+                if (furnace.isIHP) {
                     IntegratedHeatPump::SimIHP(state,
                                                BlankString,
-                                               thisFurnace.CoolingCoilIndex,
-                                               thisFurnace.fanOp,
+                                               furnace.ihpNum,
+                                               furnace.fanOp,
                                                compressorOp,
                                                PartLoadFrac,
                                                SpeedNum,
@@ -10191,8 +9076,8 @@ namespace Furnaces {
                 } else {
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                               BlankString,
-                                                              thisFurnace.CoolingCoilIndex,
-                                                              thisFurnace.fanOp,
+                                                              furnace.CoolCoilNum,
+                                                              furnace.fanOp,
                                                               compressorOp,
                                                               PartLoadFrac,
                                                               SpeedNum,
@@ -10204,14 +9089,14 @@ namespace Furnaces {
 
                 SavePartloadRatio = PartLoadFrac;
                 SaveSpeedRatio = SpeedRatio;
-                state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.CoolingCoilIndex).PartLoadRatio;
+                state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.CoolCoilNum).PartLoadRatio;
             } else {
 
-                if (thisFurnace.bIsIHP) {
+                if (furnace.isIHP) {
                     IntegratedHeatPump::SimIHP(state,
                                                BlankString,
-                                               thisFurnace.CoolingCoilIndex,
-                                               thisFurnace.fanOp,
+                                               furnace.ihpNum,
+                                               furnace.fanOp,
                                                compressorOp,
                                                PartLoadFrac,
                                                SpeedNum,
@@ -10223,17 +9108,17 @@ namespace Furnaces {
                                                OnOffAirFlowRatio);
                 } else {
                     VariableSpeedCoils::SimVariableSpeedCoils(
-                        state, BlankString, thisFurnace.CoolingCoilIndex, thisFurnace.fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRatio);
+                        state, BlankString, furnace.CoolCoilNum, furnace.fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRatio);
                 }
             }
 
-            if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatCool) {
+            if (furnace.type != HVAC::UnitarySysType::Unitary_HeatCool) {
                 if ((QZnReq > HVAC::SmallLoad) && state.dataFurnaces->HeatingLoad) {
-                    if (thisFurnace.bIsIHP) {
+                    if (furnace.isIHP) {
                         IntegratedHeatPump::SimIHP(state,
                                                    BlankString,
-                                                   thisFurnace.HeatingCoilIndex,
-                                                   thisFurnace.fanOp,
+                                                   furnace.ihpNum,
+                                                   furnace.fanOp,
                                                    compressorOp,
                                                    PartLoadFrac,
                                                    SpeedNum,
@@ -10246,8 +9131,8 @@ namespace Furnaces {
                     } else {
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                                   BlankString,
-                                                                  thisFurnace.HeatingCoilIndex,
-                                                                  thisFurnace.fanOp,
+                                                                  furnace.HeatCoilNum,
+                                                                  furnace.fanOp,
                                                                   compressorOp,
                                                                   PartLoadFrac,
                                                                   SpeedNum,
@@ -10259,13 +9144,13 @@ namespace Furnaces {
 
                     SavePartloadRatio = PartLoadFrac;
                     SaveSpeedRatio = SpeedRatio;
-                    state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.HeatingCoilIndex).PartLoadRatio;
+                    state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.HeatCoilNum).PartLoadRatio;
                 } else {
-                    if (thisFurnace.bIsIHP) {
+                    if (furnace.isIHP) {
                         IntegratedHeatPump::SimIHP(state,
                                                    BlankString,
-                                                   thisFurnace.CoolingCoilIndex,
-                                                   thisFurnace.fanOp,
+                                                   furnace.ihpNum,
+                                                   furnace.fanOp,
                                                    compressorOp,
                                                    PartLoadFrac,
                                                    SpeedNum,
@@ -10278,8 +9163,8 @@ namespace Furnaces {
                     } else {
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                                   BlankString,
-                                                                  thisFurnace.HeatingCoilIndex,
-                                                                  thisFurnace.fanOp,
+                                                                  furnace.HeatCoilNum,
+                                                                  furnace.fanOp,
                                                                   compressorOp,
                                                                   0.0,
                                                                   1,
@@ -10289,33 +9174,33 @@ namespace Furnaces {
                                                                   OnOffAirFlowRatio);
                     }
                 }
-            } else if (thisFurnace.CoolingCoilUpstream && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            } else if (furnace.CoolCoilUpstream && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
                 // simulate thisFurnace heating coil
                 bool SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, furnace.fanOp, QCoilActual);
             }
 
             //  Simulate supplemental heating coil for blow through fan
-            if (thisFurnace.SuppHeatCoilIndex > 0) {
+            if (furnace.SuppCoilNum > 0) {
                 bool SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, SupHeaterLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, SupHeaterLoad, furnace.fanOp, QCoilActual);
             }
         } else { // otherwise simulate DX coils then fan then supplemental heater
 
-            if ((!thisFurnace.CoolingCoilUpstream) && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            if ((!furnace.CoolCoilUpstream) && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
                 // simulate thisFurnace heating coil
                 bool SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, furnace.fanOp, QCoilActual);
             }
 
             if ((QZnReq < -HVAC::SmallLoad || (QLatReq < -HVAC::SmallLoad)) &&
-                (state.dataEnvrn->OutDryBulbTemp >= thisFurnace.MinOATCompressorCooling)) {
+                (state.dataEnvrn->OutDryBulbTemp >= furnace.MinOATCompressorCooling)) {
 
-                if (thisFurnace.bIsIHP) {
+                if (furnace.isIHP) {
                     IntegratedHeatPump::SimIHP(state,
                                                BlankString,
-                                               thisFurnace.CoolingCoilIndex,
-                                               thisFurnace.fanOp,
+                                               furnace.ihpNum,
+                                               furnace.fanOp,
                                                compressorOp,
                                                PartLoadFrac,
                                                SpeedNum,
@@ -10328,8 +9213,8 @@ namespace Furnaces {
                 } else {
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                               BlankString,
-                                                              thisFurnace.CoolingCoilIndex,
-                                                              thisFurnace.fanOp,
+                                                              furnace.CoolCoilNum,
+                                                              furnace.fanOp,
                                                               compressorOp,
                                                               PartLoadFrac,
                                                               SpeedNum,
@@ -10342,13 +9227,13 @@ namespace Furnaces {
                 SavePartloadRatio = PartLoadFrac;
                 SaveSpeedRatio = SpeedRatio;
 
-                state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.CoolingCoilIndex).PartLoadRatio;
+                state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.CoolCoilNum).PartLoadRatio;
             } else {
-                if (thisFurnace.bIsIHP) {
+                if (furnace.isIHP) {
                     IntegratedHeatPump::SimIHP(state,
                                                BlankString,
-                                               thisFurnace.CoolingCoilIndex,
-                                               thisFurnace.fanOp,
+                                               furnace.ihpNum,
+                                               furnace.fanOp,
                                                compressorOp,
                                                PartLoadFrac,
                                                SpeedNum,
@@ -10360,18 +9245,18 @@ namespace Furnaces {
                                                OnOffAirFlowRatio);
                 } else {
                     VariableSpeedCoils::SimVariableSpeedCoils(
-                        state, BlankString, thisFurnace.CoolingCoilIndex, thisFurnace.fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRatio);
+                        state, BlankString, furnace.CoolCoilNum, furnace.fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRatio);
                 }
             }
 
-            if (thisFurnace.type != HVAC::UnitarySysType::Unitary_HeatCool) {
-                if (QZnReq > HVAC::SmallLoad && (state.dataEnvrn->OutDryBulbTemp >= thisFurnace.MinOATCompressorCooling)) {
+            if (furnace.type != HVAC::UnitarySysType::Unitary_HeatCool) {
+                if (QZnReq > HVAC::SmallLoad && (state.dataEnvrn->OutDryBulbTemp >= furnace.MinOATCompressorCooling)) {
 
-                    if (thisFurnace.bIsIHP) {
+                    if (furnace.isIHP) {
                         IntegratedHeatPump::SimIHP(state,
                                                    BlankString,
-                                                   thisFurnace.HeatingCoilIndex,
-                                                   thisFurnace.fanOp,
+                                                   furnace.ihpNum,
+                                                   furnace.fanOp,
                                                    compressorOp,
                                                    PartLoadFrac,
                                                    SpeedNum,
@@ -10384,8 +9269,8 @@ namespace Furnaces {
                     } else {
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                                   BlankString,
-                                                                  thisFurnace.HeatingCoilIndex,
-                                                                  thisFurnace.fanOp,
+                                                                  furnace.HeatCoilNum,
+                                                                  furnace.fanOp,
                                                                   compressorOp,
                                                                   PartLoadFrac,
                                                                   SpeedNum,
@@ -10397,13 +9282,13 @@ namespace Furnaces {
 
                     SavePartloadRatio = PartLoadFrac;
                     SaveSpeedRatio = SpeedRatio;
-                    state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(thisFurnace.HeatingCoilIndex).PartLoadRatio;
+                    state.dataFurnaces->SaveCompressorPLR = state.dataVariableSpeedCoils->VarSpeedCoil(furnace.HeatCoilNum).PartLoadRatio;
                 } else {
-                    if (thisFurnace.bIsIHP) {
+                    if (furnace.isIHP) {
                         IntegratedHeatPump::SimIHP(state,
                                                    BlankString,
-                                                   thisFurnace.CoolingCoilIndex,
-                                                   thisFurnace.fanOp,
+                                                   furnace.ihpNum,
+                                                   furnace.fanOp,
                                                    compressorOp,
                                                    PartLoadFrac,
                                                    SpeedNum,
@@ -10416,8 +9301,8 @@ namespace Furnaces {
                     } else {
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
                                                                   BlankString,
-                                                                  thisFurnace.HeatingCoilIndex,
-                                                                  thisFurnace.fanOp,
+                                                                  furnace.HeatCoilNum,
+                                                                  furnace.fanOp,
                                                                   compressorOp,
                                                                   0.0,
                                                                   1,
@@ -10427,32 +9312,32 @@ namespace Furnaces {
                                                                   OnOffAirFlowRatio);
                     }
                 }
-            } else if (thisFurnace.CoolingCoilUpstream && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            } else if (furnace.CoolCoilUpstream && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
                 // simulate thisFurnace heating coil
                 bool SuppHeatingCoilFlag = false; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, HeatCoilLoad, furnace.fanOp, QCoilActual);
             }
 
-            state.dataFans->fans(thisFurnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
+            state.dataFans->fans(furnace.FanIndex)->simulate(state, FirstHVACIteration, state.dataFurnaces->FanSpeedRatio);
             //  Simulate supplemental heating coil for draw through fan
-            if (thisFurnace.SuppHeatCoilIndex > 0) {
+            if (furnace.SuppCoilNum > 0) {
                 bool SuppHeatingCoilFlag = true; // if true simulates supplemental heating coil
-                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, SupHeaterLoad, thisFurnace.fanOp, QCoilActual);
+                CalcNonDXHeatingCoils(state, FurnaceNum, SuppHeatingCoilFlag, FirstHVACIteration, SupHeaterLoad, furnace.fanOp, QCoilActual);
             }
         }
 
         // If the fan runs continually do not allow coils to set OnOffFanPartLoadRatio.
-        if (thisFurnace.fanOp == HVAC::FanOp::Continuous) state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
+        if (furnace.fanOp == HVAC::FanOp::Continuous) state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
 
-        auto &outNode = state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum);
-        auto &zoneNode = state.dataLoopNodes->Node(thisFurnace.NodeNumOfControlledZone);
+        auto &outNode = state.dataLoopNodes->Node(furnace.FurnaceOutletNode);
+        auto &zoneNode = state.dataLoopNodes->Node(furnace.NodeNumOfControlledZone);
         Real64 zoneEnthalpy = Psychrometrics::PsyHFnTdbW(zoneNode.Temp, zoneNode.HumRat);
         Real64 outletEnthalpy = Psychrometrics::PsyHFnTdbW(outNode.Temp, outNode.HumRat);
         Real64 totalLoadMet = AirMassFlow * (outletEnthalpy - zoneEnthalpy);
         SensibleLoadMet =
             AirMassFlow * Psychrometrics::PsyDeltaHSenFnTdb2W2Tdb1W1(outNode.Temp, outNode.HumRat, zoneNode.Temp, zoneNode.HumRat); // sensible {W};
         LatentLoadMet = totalLoadMet - SensibleLoadMet;
-        thisFurnace.LatentLoadMet = LatentLoadMet;
+        furnace.LatentLoadMet = LatentLoadMet;
     }
 
     //******************************************************************************
@@ -10618,28 +9503,28 @@ namespace Furnaces {
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         Real64 AverageUnitMassFlow; // average supply air mass flow rate over time step
 
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
         state.dataHVACGlobal->MSHPMassFlowRateLow = 0.0;  // Mass flow rate at low speed
         state.dataHVACGlobal->MSHPMassFlowRateHigh = 0.0; // Mass flow rate at high speed
 
-        if (thisFurnace.fanOp == HVAC::FanOp::Continuous) {
-            state.dataFurnaces->CompOffMassFlow = thisFurnace.IdleMassFlowRate;
-            state.dataFurnaces->CompOffFlowRatio = thisFurnace.IdleSpeedRatio;
+        if (furnace.fanOp == HVAC::FanOp::Continuous) {
+            state.dataFurnaces->CompOffMassFlow = furnace.IdleMassFlowRate;
+            state.dataFurnaces->CompOffFlowRatio = furnace.IdleSpeedRatio;
         } else {
             state.dataFurnaces->CompOffMassFlow = 0.0;
             state.dataFurnaces->CompOffFlowRatio = 0.0;
         }
 
-        if (state.dataFurnaces->CoolingLoad && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
-            if (thisFurnace.NumOfSpeedCooling > 0) {
-                state.dataFurnaces->CompOnMassFlow = thisFurnace.CoolMassFlowRate(thisFurnace.NumOfSpeedCooling);
-                state.dataFurnaces->CompOnFlowRatio = thisFurnace.MSCoolingSpeedRatio(thisFurnace.NumOfSpeedCooling);
-                state.dataHVACGlobal->MSHPMassFlowRateLow = thisFurnace.CoolMassFlowRate(thisFurnace.NumOfSpeedCooling);
-                state.dataHVACGlobal->MSHPMassFlowRateHigh = thisFurnace.CoolMassFlowRate(thisFurnace.NumOfSpeedCooling);
+        if (state.dataFurnaces->CoolingLoad && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            if (furnace.NumOfSpeedCooling > 0) {
+                state.dataFurnaces->CompOnMassFlow = furnace.CoolMassFlowRate(furnace.NumOfSpeedCooling);
+                state.dataFurnaces->CompOnFlowRatio = furnace.MSCoolingSpeedRatio(furnace.NumOfSpeedCooling);
+                state.dataHVACGlobal->MSHPMassFlowRateLow = furnace.CoolMassFlowRate(furnace.NumOfSpeedCooling);
+                state.dataHVACGlobal->MSHPMassFlowRateHigh = furnace.CoolMassFlowRate(furnace.NumOfSpeedCooling);
             } else {
-                state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxCoolAirMassFlow;
-                state.dataFurnaces->CompOnFlowRatio = thisFurnace.CoolingSpeedRatio;
+                state.dataFurnaces->CompOnMassFlow = furnace.MaxCoolAirMassFlow;
+                state.dataFurnaces->CompOnFlowRatio = furnace.CoolingSpeedRatio;
             }
             AverageUnitMassFlow = (PartLoadRatio * state.dataFurnaces->CompOnMassFlow) + ((1 - PartLoadRatio) * state.dataFurnaces->CompOffMassFlow);
             if (state.dataFurnaces->CompOffFlowRatio > 0.0) {
@@ -10648,15 +9533,15 @@ namespace Furnaces {
             } else {
                 state.dataFurnaces->FanSpeedRatio = state.dataFurnaces->CompOnFlowRatio;
             }
-        } else if (state.dataFurnaces->HeatingLoad && (thisFurnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
-            if (thisFurnace.NumOfSpeedHeating > 0) {
-                state.dataFurnaces->CompOnMassFlow = thisFurnace.HeatMassFlowRate(thisFurnace.NumOfSpeedHeating);
-                state.dataFurnaces->CompOnFlowRatio = thisFurnace.MSHeatingSpeedRatio(thisFurnace.NumOfSpeedHeating);
-                state.dataHVACGlobal->MSHPMassFlowRateLow = thisFurnace.HeatMassFlowRate(thisFurnace.NumOfSpeedHeating);
-                state.dataHVACGlobal->MSHPMassFlowRateHigh = thisFurnace.HeatMassFlowRate(thisFurnace.NumOfSpeedHeating);
+        } else if (state.dataFurnaces->HeatingLoad && (furnace.type == HVAC::UnitarySysType::Unitary_HeatCool)) {
+            if (furnace.NumOfSpeedHeating > 0) {
+                state.dataFurnaces->CompOnMassFlow = furnace.HeatMassFlowRate(furnace.NumOfSpeedHeating);
+                state.dataFurnaces->CompOnFlowRatio = furnace.MSHeatingSpeedRatio(furnace.NumOfSpeedHeating);
+                state.dataHVACGlobal->MSHPMassFlowRateLow = furnace.HeatMassFlowRate(furnace.NumOfSpeedHeating);
+                state.dataHVACGlobal->MSHPMassFlowRateHigh = furnace.HeatMassFlowRate(furnace.NumOfSpeedHeating);
             } else {
-                state.dataFurnaces->CompOnMassFlow = thisFurnace.MaxHeatAirMassFlow;
-                state.dataFurnaces->CompOnFlowRatio = thisFurnace.HeatingSpeedRatio;
+                state.dataFurnaces->CompOnMassFlow = furnace.MaxHeatAirMassFlow;
+                state.dataFurnaces->CompOnFlowRatio = furnace.HeatingSpeedRatio;
             }
             AverageUnitMassFlow = (PartLoadRatio * state.dataFurnaces->CompOnMassFlow) + ((1 - PartLoadRatio) * state.dataFurnaces->CompOffMassFlow);
             if (state.dataFurnaces->CompOffFlowRatio > 0.0) {
@@ -10665,31 +9550,31 @@ namespace Furnaces {
             } else {
                 state.dataFurnaces->FanSpeedRatio = state.dataFurnaces->CompOnFlowRatio;
             }
-        } else if (thisFurnace.bIsIHP) {
-            if (!state.dataZoneEnergyDemand->CurDeadBandOrSetback(thisFurnace.ControlZoneNum) && present(SpeedNum)) {
+        } else if (furnace.isIHP) {
+            if (!state.dataZoneEnergyDemand->CurDeadBandOrSetback(furnace.ControlZoneNum) && present(SpeedNum)) {
                 // if(present(SpeedNum)) {
                 state.dataFurnaces->CompOnMassFlow =
-                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, thisFurnace.CoolingCoilIndex, SpeedNum, SpeedRatio, false);
+                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, furnace.ihpNum, SpeedNum, SpeedRatio, false);
                 state.dataFurnaces->CompOnFlowRatio =
                     state.dataFurnaces->CompOnMassFlow /
                     IntegratedHeatPump::GetAirMassFlowRateIHP(
-                        state, thisFurnace.CoolingCoilIndex, IntegratedHeatPump::GetMaxSpeedNumIHP(state, thisFurnace.CoolingCoilIndex), 1.0, false);
+                        state, furnace.ihpNum, IntegratedHeatPump::GetMaxSpeedNumIHP(state, furnace.ihpNum), 1.0, false);
                 state.dataHVACGlobal->MSHPMassFlowRateLow =
-                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, thisFurnace.CoolingCoilIndex, SpeedNum, 0.0, false);
+                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, furnace.ihpNum, SpeedNum, 0.0, false);
                 state.dataHVACGlobal->MSHPMassFlowRateHigh =
-                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, thisFurnace.CoolingCoilIndex, SpeedNum, 1.0, false);
+                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, furnace.ihpNum, SpeedNum, 1.0, false);
             }
 
             // Set up fan flow rate during compressor off time
-            if (thisFurnace.fanOp == HVAC::FanOp::Continuous && present(SpeedNum)) {
-                if (thisFurnace.AirFlowControl == AirFlowControlConstFan::UseCompressorOnFlow && state.dataFurnaces->CompOnMassFlow > 0.0) {
+            if (furnace.fanOp == HVAC::FanOp::Continuous && present(SpeedNum)) {
+                if (furnace.AirFlowControl == AirFlowControlConstFan::UseCompressorOnFlow && state.dataFurnaces->CompOnMassFlow > 0.0) {
                     state.dataFurnaces->CompOffMassFlow =
-                        IntegratedHeatPump::GetAirMassFlowRateIHP(state, thisFurnace.CoolingCoilIndex, SpeedNum, 1.0, false);
+                        IntegratedHeatPump::GetAirMassFlowRateIHP(state, furnace.ihpNum, SpeedNum, 1.0, false);
                     state.dataFurnaces->CompOffFlowRatio =
                         state.dataFurnaces->CompOffMassFlow /
                         IntegratedHeatPump::GetAirMassFlowRateIHP(state,
-                                                                  thisFurnace.CoolingCoilIndex,
-                                                                  IntegratedHeatPump::GetMaxSpeedNumIHP(state, thisFurnace.CoolingCoilIndex),
+                                                                  furnace.ihpNum,
+                                                                  IntegratedHeatPump::GetMaxSpeedNumIHP(state, furnace.ihpNum),
                                                                   1.0,
                                                                   false);
                 }
@@ -10721,56 +9606,56 @@ namespace Furnaces {
             }
 
             if (IntegratedHeatPump::IHPOperationMode::SCWHMatchWH ==
-                state.dataIntegratedHP->IntegratedHeatPumps(thisFurnace.CoolingCoilIndex).CurMode) {
+                state.dataIntegratedHP->IntegratedHeatPumps(furnace.ihpNum).CurMode) {
                 state.dataFurnaces->CompOnMassFlow =
-                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, thisFurnace.CoolingCoilIndex, SpeedNum, SpeedRatio, false);
+                    IntegratedHeatPump::GetAirMassFlowRateIHP(state, furnace.ihpNum, SpeedNum, SpeedRatio, false);
                 AverageUnitMassFlow = state.dataFurnaces->CompOnMassFlow;
             }
         } else {
-            if (!state.dataZoneEnergyDemand->CurDeadBandOrSetback(thisFurnace.ControlZoneNum) && present(SpeedNum)) {
-                if (thisFurnace.HeatCoolMode == Furnaces::ModeOfOperation::HeatingMode) {
+            if (!state.dataZoneEnergyDemand->CurDeadBandOrSetback(furnace.ControlZoneNum) && present(SpeedNum)) {
+                if (furnace.HeatCoolMode == Furnaces::ModeOfOperation::HeatingMode) {
                     if (SpeedNum == 1) {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.HeatMassFlowRate(SpeedNum);
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.MSHeatingSpeedRatio(SpeedNum);
-                        state.dataHVACGlobal->MSHPMassFlowRateLow = thisFurnace.HeatMassFlowRate(1);
-                        state.dataHVACGlobal->MSHPMassFlowRateHigh = thisFurnace.HeatMassFlowRate(1);
+                        state.dataFurnaces->CompOnMassFlow = furnace.HeatMassFlowRate(SpeedNum);
+                        state.dataFurnaces->CompOnFlowRatio = furnace.MSHeatingSpeedRatio(SpeedNum);
+                        state.dataHVACGlobal->MSHPMassFlowRateLow = furnace.HeatMassFlowRate(1);
+                        state.dataHVACGlobal->MSHPMassFlowRateHigh = furnace.HeatMassFlowRate(1);
                     } else if (SpeedNum > 1) {
                         state.dataFurnaces->CompOnMassFlow =
-                            SpeedRatio * thisFurnace.HeatMassFlowRate(SpeedNum) + (1.0 - SpeedRatio) * thisFurnace.HeatMassFlowRate(SpeedNum - 1);
-                        state.dataFurnaces->CompOnFlowRatio = SpeedRatio * thisFurnace.MSHeatingSpeedRatio(SpeedNum) +
-                                                              (1.0 - SpeedRatio) * thisFurnace.MSHeatingSpeedRatio(SpeedNum - 1);
-                        state.dataHVACGlobal->MSHPMassFlowRateLow = thisFurnace.HeatMassFlowRate(SpeedNum - 1);
-                        state.dataHVACGlobal->MSHPMassFlowRateHigh = thisFurnace.HeatMassFlowRate(SpeedNum);
+                            SpeedRatio * furnace.HeatMassFlowRate(SpeedNum) + (1.0 - SpeedRatio) * furnace.HeatMassFlowRate(SpeedNum - 1);
+                        state.dataFurnaces->CompOnFlowRatio = SpeedRatio * furnace.MSHeatingSpeedRatio(SpeedNum) +
+                                                              (1.0 - SpeedRatio) * furnace.MSHeatingSpeedRatio(SpeedNum - 1);
+                        state.dataHVACGlobal->MSHPMassFlowRateLow = furnace.HeatMassFlowRate(SpeedNum - 1);
+                        state.dataHVACGlobal->MSHPMassFlowRateHigh = furnace.HeatMassFlowRate(SpeedNum);
                     }
-                } else if (thisFurnace.HeatCoolMode == Furnaces::ModeOfOperation::CoolingMode) {
+                } else if (furnace.HeatCoolMode == Furnaces::ModeOfOperation::CoolingMode) {
                     if (SpeedNum == 1) {
-                        state.dataFurnaces->CompOnMassFlow = thisFurnace.CoolMassFlowRate(SpeedNum);
-                        state.dataFurnaces->CompOnFlowRatio = thisFurnace.MSCoolingSpeedRatio(SpeedNum);
-                        state.dataHVACGlobal->MSHPMassFlowRateLow = thisFurnace.CoolMassFlowRate(1);
-                        state.dataHVACGlobal->MSHPMassFlowRateHigh = thisFurnace.CoolMassFlowRate(1);
+                        state.dataFurnaces->CompOnMassFlow = furnace.CoolMassFlowRate(SpeedNum);
+                        state.dataFurnaces->CompOnFlowRatio = furnace.MSCoolingSpeedRatio(SpeedNum);
+                        state.dataHVACGlobal->MSHPMassFlowRateLow = furnace.CoolMassFlowRate(1);
+                        state.dataHVACGlobal->MSHPMassFlowRateHigh = furnace.CoolMassFlowRate(1);
                     } else if (SpeedNum > 1) {
                         state.dataFurnaces->CompOnMassFlow =
-                            SpeedRatio * thisFurnace.CoolMassFlowRate(SpeedNum) + (1.0 - SpeedRatio) * thisFurnace.CoolMassFlowRate(SpeedNum - 1);
-                        state.dataFurnaces->CompOnFlowRatio = SpeedRatio * thisFurnace.MSCoolingSpeedRatio(SpeedNum) +
-                                                              (1.0 - SpeedRatio) * thisFurnace.MSCoolingSpeedRatio(SpeedNum - 1);
-                        state.dataHVACGlobal->MSHPMassFlowRateLow = thisFurnace.CoolMassFlowRate(SpeedNum - 1);
-                        state.dataHVACGlobal->MSHPMassFlowRateHigh = thisFurnace.CoolMassFlowRate(SpeedNum);
+                            SpeedRatio * furnace.CoolMassFlowRate(SpeedNum) + (1.0 - SpeedRatio) * furnace.CoolMassFlowRate(SpeedNum - 1);
+                        state.dataFurnaces->CompOnFlowRatio = SpeedRatio * furnace.MSCoolingSpeedRatio(SpeedNum) +
+                                                              (1.0 - SpeedRatio) * furnace.MSCoolingSpeedRatio(SpeedNum - 1);
+                        state.dataHVACGlobal->MSHPMassFlowRateLow = furnace.CoolMassFlowRate(SpeedNum - 1);
+                        state.dataHVACGlobal->MSHPMassFlowRateHigh = furnace.CoolMassFlowRate(SpeedNum);
                     }
                 }
             }
 
             // Set up fan flow rate during compressor off time
-            if (thisFurnace.fanOp == HVAC::FanOp::Continuous && present(SpeedNum)) {
-                if (thisFurnace.AirFlowControl == AirFlowControlConstFan::UseCompressorOnFlow && state.dataFurnaces->CompOnMassFlow > 0.0) {
+            if (furnace.fanOp == HVAC::FanOp::Continuous && present(SpeedNum)) {
+                if (furnace.AirFlowControl == AirFlowControlConstFan::UseCompressorOnFlow && state.dataFurnaces->CompOnMassFlow > 0.0) {
                     if (SpeedNum == 1) { // LOWEST SPEED USE IDLE FLOW
-                        state.dataFurnaces->CompOffMassFlow = thisFurnace.IdleMassFlowRate;
-                        state.dataFurnaces->CompOffFlowRatio = thisFurnace.IdleSpeedRatio;
-                    } else if (thisFurnace.LastMode == Furnaces::ModeOfOperation::HeatingMode) {
-                        state.dataFurnaces->CompOffMassFlow = thisFurnace.HeatMassFlowRate(SpeedNum);
-                        state.dataFurnaces->CompOffFlowRatio = thisFurnace.MSHeatingSpeedRatio(SpeedNum);
+                        state.dataFurnaces->CompOffMassFlow = furnace.IdleMassFlowRate;
+                        state.dataFurnaces->CompOffFlowRatio = furnace.IdleSpeedRatio;
+                    } else if (furnace.LastMode == Furnaces::ModeOfOperation::HeatingMode) {
+                        state.dataFurnaces->CompOffMassFlow = furnace.HeatMassFlowRate(SpeedNum);
+                        state.dataFurnaces->CompOffFlowRatio = furnace.MSHeatingSpeedRatio(SpeedNum);
                     } else {
-                        state.dataFurnaces->CompOffMassFlow = thisFurnace.CoolMassFlowRate(SpeedNum);
-                        state.dataFurnaces->CompOffFlowRatio = thisFurnace.MSCoolingSpeedRatio(SpeedNum);
+                        state.dataFurnaces->CompOffMassFlow = furnace.CoolMassFlowRate(SpeedNum);
+                        state.dataFurnaces->CompOffFlowRatio = furnace.MSCoolingSpeedRatio(SpeedNum);
                     }
                 }
             }
@@ -10801,13 +9686,13 @@ namespace Furnaces {
             }
         }
 
-        if ((thisFurnace.availSched->getCurrentVal() == 0.0) || state.dataHVACGlobal->TurnFansOff ||
-            (thisFurnace.fanAvailSched->getCurrentVal() == 0.0 && !state.dataHVACGlobal->TurnFansOn)) {
-            state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum).MassFlowRate = 0.0;
+        if ((furnace.availSched->getCurrentVal() == 0.0) || state.dataHVACGlobal->TurnFansOff ||
+            (furnace.fanAvailSched->getCurrentVal() == 0.0 && !state.dataHVACGlobal->TurnFansOn)) {
+            state.dataLoopNodes->Node(furnace.FurnaceInletNode).MassFlowRate = 0.0;
             OnOffAirFlowRatio = 0.0;
         } else {
-            state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum).MassFlowRate = AverageUnitMassFlow;
-            state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum).MassFlowRateMaxAvail = AverageUnitMassFlow;
+            state.dataLoopNodes->Node(furnace.FurnaceInletNode).MassFlowRate = AverageUnitMassFlow;
+            state.dataLoopNodes->Node(furnace.FurnaceInletNode).MassFlowRateMaxAvail = AverageUnitMassFlow;
             if (AverageUnitMassFlow > 0.0) {
                 OnOffAirFlowRatio = state.dataFurnaces->CompOnMassFlow / AverageUnitMassFlow;
             } else {
@@ -10815,8 +9700,8 @@ namespace Furnaces {
             }
         }
 
-        state.dataLoopNodes->Node(thisFurnace.FurnaceOutletNodeNum).MassFlowRate =
-            state.dataLoopNodes->Node(thisFurnace.FurnaceInletNodeNum).MassFlowRate;
+        state.dataLoopNodes->Node(furnace.FurnaceOutletNode).MassFlowRate =
+            state.dataLoopNodes->Node(furnace.FurnaceInletNode).MassFlowRate;
     }
 
     void SetMinOATCompressor(EnergyPlusData &state,
@@ -10826,52 +9711,45 @@ namespace Furnaces {
     )
     {
         bool errFlag = false;
-        auto &thisFurnace = state.dataFurnaces->Furnace(FurnaceNum);
+        auto &furnace = state.dataFurnaces->Furnaces(FurnaceNum);
 
         // Set minimum OAT for heat pump compressor operation in heating mode
-        if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-            thisFurnace.MinOATCompressorCooling = DXCoils::GetMinOATCompressor(state, thisFurnace.CoolingCoilIndex, errFlag);
-        } else if (thisFurnace.CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-            std::string ChildCoolingCoilType = state.dataHVACAssistedCC->HXAssistedCoil(thisFurnace.CoolingCoilIndex).CoolingCoilType;
-            std::string ChildCoolingCoilName = state.dataHVACAssistedCC->HXAssistedCoil(thisFurnace.CoolingCoilIndex).CoolingCoilName;
-
-            if (Util::SameString(ChildCoolingCoilType, "COIL:COOLING:DX")) {
-                int childCCIndex_DX = CoilCoolingDX::factory(state, ChildCoolingCoilName);
-                if (childCCIndex_DX < 0) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisFurnace.Name));
-                    errFlag = true;
-                    ErrorsFound = true;
-                }
-                auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex_DX];
-                thisFurnace.MinOATCompressorCooling = newCoil.performance.minOutdoorDrybulb;
-            } else if (Util::SameString(ChildCoolingCoilType, "Coil:Cooling:DX:VariableSpeed")) {
-                int childCCIndex_VS = state.dataHVACAssistedCC->HXAssistedCoil(thisFurnace.CoolingCoilIndex).CoolingCoilIndex;
-                thisFurnace.MinOATCompressorCooling = VariableSpeedCoils::GetVSCoilMinOATCompressor(state, childCCIndex_VS, errFlag);
-            } else { // Single speed
-                int childCCIndex_SP = state.dataHVACAssistedCC->HXAssistedCoil(thisFurnace.CoolingCoilIndex).CoolingCoilIndex;
-                thisFurnace.MinOATCompressorCooling = DXCoils::GetMinOATCompressor(state, childCCIndex_SP, errFlag);
-            }
-        } else if (thisFurnace.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            thisFurnace.MinOATCompressorCooling = VariableSpeedCoils::GetVSCoilMinOATCompressor(state, thisFurnace.CoolingCoilIndex, errFlag);
+
+        // If this is an HXAssistedCoil then CoolCoilNum is already the index of the embedded coil
+        if (furnace.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+            furnace.MinOATCompressorCooling = DXCoils::GetCoilMinOATCompressor(state, furnace.CoolCoilNum);
+
+        } else if (furnace.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+            if (furnace.childCoolCoilType == HVAC::CoilType::CoolingDX) {
+                auto const &dxCoil = state.dataCoilCoolingDX->coilCoolingDXs[furnace.childCoolCoilNum];
+                furnace.MinOATCompressorCooling = dxCoil.performance.minOutdoorDrybulb;
+            } else if (furnace.childCoolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                furnace.MinOATCompressorCooling = VariableSpeedCoils::GetCoilMinOATCompressor(state, furnace.childCoolCoilNum);
+            } else { 
+                furnace.MinOATCompressorCooling = DXCoils::GetCoilMinOATCompressor(state, furnace.childCoolCoilNum);
+            }
+            
+        } else if (furnace.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            furnace.MinOATCompressorCooling = VariableSpeedCoils::GetCoilMinOATCompressor(state, furnace.CoolCoilNum);
         } else {
-            thisFurnace.MinOATCompressorCooling = -1000.0;
+            furnace.MinOATCompressorCooling = -1000.0;
         }
         if (errFlag) {
-            ShowContinueError(state, format("...occurs in {} = {}", cCurrentModuleObject, thisFurnace.Name));
+            ShowContinueError(state, format("...occurs in {} = {}", cCurrentModuleObject, furnace.Name));
             ErrorsFound = true;
         }
 
         // Set minimum OAT for heat pump compressor operation in heating mode
         errFlag = false;
-        if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-            thisFurnace.MinOATCompressorHeating = VariableSpeedCoils::GetVSCoilMinOATCompressor(state, thisFurnace.HeatingCoilIndex, errFlag);
-        } else if (thisFurnace.HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-            thisFurnace.MinOATCompressorHeating = DXCoils::GetMinOATCompressor(state, thisFurnace.HeatingCoilIndex, errFlag);
+        if (furnace.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+            furnace.MinOATCompressorHeating = VariableSpeedCoils::GetCoilMinOATCompressor(state, furnace.HeatCoilNum);
+        } else if (furnace.heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
+            furnace.MinOATCompressorHeating = DXCoils::GetCoilMinOATCompressor(state, furnace.HeatCoilNum);
         } else {
-            thisFurnace.MinOATCompressorHeating = -1000.0;
+            furnace.MinOATCompressorHeating = -1000.0;
         }
         if (errFlag) {
-            ShowContinueError(state, format("...occurs in {} = {}", cCurrentModuleObject, thisFurnace.Name));
+            ShowContinueError(state, format("...occurs in {} = {}", cCurrentModuleObject, furnace.Name));
             ErrorsFound = true;
         }
     }
diff --git a/src/EnergyPlus/Furnaces.hh b/src/EnergyPlus/Furnaces.hh
index 1596214e3e0..90e946433f5 100644
--- a/src/EnergyPlus/Furnaces.hh
+++ b/src/EnergyPlus/Furnaces.hh
@@ -117,35 +117,50 @@ namespace Furnaces {
         int ControlZoneNum;                                        // Index to controlled zone
         int ZoneSequenceCoolingNum;                                // Index to cooling sequence/priority for this zone
         int ZoneSequenceHeatingNum;                                // Index to heating sequence/priority for this zone
-        int CoolingCoilType_Num;                                   // Numeric Equivalent for Cooling Coil Type
-        int CoolingCoilIndex;                                      // Index to cooling coil
+
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;     // Numeric Equivalent for Cooling Coil Type
+        std::string CoolCoilName;
+        int CoolCoilNum = 0;                                      // Index to cooling coil
+        int CoolCoilAirInletNode = 0;                           // air inlet node number of HW coil for PTAC, PTHP, HeatCool, HeatOnly
+        int CoolCoilAirOutletNode = 0;                          // air outlet node number of HW coil for PTAC, PTHP, HeatCool, HeatOnly
         int ActualDXCoilIndexForHXAssisted;                        // Index to DX cooling coil when HX assisted
-        bool CoolingCoilUpstream;                                  // Indicates if cooling coil is upstream of heating coil
-        int HeatingCoilType_Num;                                   // Numeric Equivalent for Heating Coil Type
-        int HeatingCoilIndex;                                      // Index to heating coil
-        int ReheatingCoilType_Num;                                 // Numeric Equivalent for Reheat Coil Type
-        int ReheatingCoilIndex;                                    // Index to reheat coil
-        std::string HeatingCoilName;                               // name of heating coil
-        std::string HeatingCoilType;                               // type of heating coil
-        int CoilControlNode;                                       // control node for hot water and steam heating coils
-        int HWCoilAirInletNode;                                    // air inlet node number of HW coil for PTAC, PTHP, HeatCool, HeatOnly
-        int HWCoilAirOutletNode;                                   // air outlet node number of HW coil for PTAC, PTHP, HeatCool, HeatOnly
-        int SuppCoilAirInletNode;                                  // air inlet node number of HW coil for HeatCool Reheat Coil
-        int SuppCoilAirOutletNode;                                 // air outlet node number of HW coil for HeatCool Reheat Coil
-        int SuppHeatCoilType_Num;                                  // Numeric Equivalent for Supplemental Heat Coil Type
-        int SuppHeatCoilIndex;                                     // Index to supplemental heater
-        int SuppCoilControlNode;                                   // control node for steam and hot water heating coil
-        std::string SuppHeatCoilName;                              // name of supplemental heating coil
-        std::string SuppHeatCoilType;                              // type of supplemental heating coil
+        bool CoolCoilUpstream = true;                                  // Indicates if cooling coil is upstream of heating coil
+
+        // If the cooling coil is HXAssisted, these correspond to embedded "child" coil
+        HVAC::CoilType childCoolCoilType = HVAC::CoilType::Invalid;     
+        std::string childCoolCoilName;
+        int childCoolCoilNum = 0;                                     
+
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;     // Numeric Equivalent for Heating Coil Type
+        std::string HeatCoilName;                               // name of heating coil
+        int HeatCoilNum = 0;                                      // Index to heating coil
+        int HeatCoilControlNode = 0;                            // control node for hot water and steam heating coils
+        int HeatCoilAirInletNode = 0;                           // air inlet node number of HW coil for PTAC, PTHP, HeatCool, HeatOnly
+        int HeatCoilAirOutletNode = 0;                          // air outlet node number of HW coil for PTAC, PTHP, HeatCool, HeatOnly
+        int HeatCoilPLFCurveIndex = 0;
+      
+        HVAC::CoilType suppHeatCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for Supplemental Heat Coil Type
+        std::string SuppCoilName;                              // name of supplemental heating coil
+        int SuppCoilNum = 0;                                     // Index to supplemental heater
+        int SuppCoilControlNode = 0;                                   // control node for steam and hot water heating coil
+        int SuppCoilAirInletNode = 0;                                  // air inlet node number of HW coil for HeatCool Reheat Coil
+        int SuppCoilAirOutletNode = 0;                                 // air outlet node number of HW coil for HeatCool Reheat Coil
+      
+        bool isIHP = false;
+        std::string ihpName;                                       // Save IHP name and index
+        int ihpNum = 0;
+
         HVAC::FanType fanType;                                     // Integer equivalent of fan type (1=OnOff, 2 = ConstVolume)
         int FanIndex;                                              // Index to fan object
-        int FurnaceInletNodeNum;                                   // Furnace inlet node number
-        int FurnaceOutletNodeNum;                                  // Furnace inlet node number
+        int FurnaceInletNode = 0;                                   // Furnace inlet node number
+        int FurnaceOutletNode = 0;                                  // Furnace inlet node number
         HVAC::FanOp fanOp = HVAC::FanOp::Invalid;                  // operation mode: 1 = cycling fan, cycling coils
         //                 2 = continuous fan, cycling coils
         Furnaces::ModeOfOperation LastMode;                    // last mode of operation, coolingmode or heatingmode
         AirFlowControlConstFan AirFlowControl;                 // fan control mode, UseCompressorOnFlow or UseCompressorOffFlow
         HVAC::FanPlace fanPlace;                               // fan placement; 1=blow through, 2=draw through
+        int FanInletNode = 0;
+        int FanOutletNode = 0;
         int NodeNumOfControlledZone;                           // Node number of controlled zone air node
         WAHPCoilType WatertoAirHPType = WAHPCoilType::Invalid; // Type of water to air heat pump model used
         Real64 CoolingConvergenceTolerance;                    // Convergence tolerance for cooling,
@@ -238,7 +253,7 @@ namespace Furnaces {
         Array1D<Real64> CoolMassFlowRate;       // Supply air mass flow rate during cooling operation
         Array1D<Real64> MSHeatingSpeedRatio;    // Fan speed ratio in heating mode
         Array1D<Real64> MSCoolingSpeedRatio;    // Fan speed ratio in cooling mode
-        bool bIsIHP;
+
         int CompSpeedNum;
         Real64 CompSpeedRatio;
         int ErrIndexCyc;
@@ -255,34 +270,32 @@ namespace Furnaces {
         int ErrCountVar2 = 0; // Counter used to minimize the occurrence of output warnings
 
         FurnaceEquipConditions()
-            : FurnaceIndex(0), ControlZoneNum(0), ZoneSequenceCoolingNum(0), ZoneSequenceHeatingNum(0), CoolingCoilType_Num(0), CoolingCoilIndex(0),
-              ActualDXCoilIndexForHXAssisted(0), CoolingCoilUpstream(true), HeatingCoilType_Num(0), HeatingCoilIndex(0), ReheatingCoilType_Num(0),
-              ReheatingCoilIndex(0), CoilControlNode(0), HWCoilAirInletNode(0), HWCoilAirOutletNode(0), SuppCoilAirInletNode(0),
-              SuppCoilAirOutletNode(0), SuppHeatCoilType_Num(0), SuppHeatCoilIndex(0), SuppCoilControlNode(0), fanType(HVAC::FanType::Invalid),
-              FanIndex(0), FurnaceInletNodeNum(0), FurnaceOutletNodeNum(0), LastMode(Furnaces::ModeOfOperation::Invalid),
-              AirFlowControl(AirFlowControlConstFan::Invalid), fanPlace(HVAC::FanPlace::Invalid), NodeNumOfControlledZone(0),
-              CoolingConvergenceTolerance(0.0), HeatingConvergenceTolerance(0.0), DesignHeatingCapacity(0.0), DesignCoolingCapacity(0.0),
-              CoolingCoilSensDemand(0.0), HeatingCoilSensDemand(0.0), CoolingCoilLatentDemand(0.0), DesignSuppHeatingCapacity(0.0),
-              DesignFanVolFlowRate(0.0), DesignFanVolFlowRateEMSOverrideOn(false), DesignFanVolFlowRateEMSOverrideValue(0.0), DesignMassFlowRate(0.0),
-              MaxCoolAirVolFlow(0.0), MaxCoolAirVolFlowEMSOverrideOn(false), MaxCoolAirVolFlowEMSOverrideValue(0.0), MaxHeatAirVolFlow(0.0),
-              MaxHeatAirVolFlowEMSOverrideOn(false), MaxHeatAirVolFlowEMSOverrideValue(0.0), MaxNoCoolHeatAirVolFlow(0.0),
-              MaxNoCoolHeatAirVolFlowEMSOverrideOn(false), MaxNoCoolHeatAirVolFlowEMSOverrideValue(0.0), MaxCoolAirMassFlow(0.0),
-              MaxHeatAirMassFlow(0.0), MaxNoCoolHeatAirMassFlow(0.0), MaxHeatCoilFluidFlow(0.0), MaxSuppCoilFluidFlow(0.0),
-              ControlZoneMassFlowFrac(0.0), DesignMaxOutletTemp(9999.0), MdotFurnace(0.0), FanPartLoadRatio(0.0), CompPartLoadRatio(0.0),
-              CoolPartLoadRatio(0.0), HeatPartLoadRatio(0.0), MinOATCompressorCooling(0.0), MinOATCompressorHeating(0.0), MaxOATSuppHeat(0.0),
-              CondenserNodeNum(0), Humidistat(false), InitHeatPump(false), DehumidControlType_Num(DehumidificationControlMode::None),
-              LatentMaxIterIndex(0), LatentRegulaFalsiFailedIndex(0), LatentRegulaFalsiFailedIndex2(0), SensibleMaxIterIndex(0),
-              SensibleRegulaFalsiFailedIndex(0), WSHPHeatMaxIterIndex(0), WSHPHeatRegulaFalsiFailedIndex(0), DXHeatingMaxIterIndex(0),
-              DXHeatingRegulaFalsiFailedIndex(0), HeatingMaxIterIndex(0), HeatingMaxIterIndex2(0), HeatingRegulaFalsiFailedIndex(0),
-              ActualFanVolFlowRate(0.0), HeatingSpeedRatio(1.0), CoolingSpeedRatio(1.0), NoHeatCoolSpeedRatio(1.0), ZoneInletNode(0),
-              SenLoadLoss(0.0), LatLoadLoss(0.0), SensibleLoadMet(0.0), LatentLoadMet(0.0), DehumidInducedHeatingDemandRate(0.0),
-              CoilOutletNode(0), plantLoc{}, SuppPlantLoc{}, HotWaterCoilMaxIterIndex(0), HotWaterCoilMaxIterIndex2(0),
-              EMSOverrideSensZoneLoadRequest(false), EMSSensibleZoneLoadValue(0.0), EMSOverrideMoistZoneLoadRequest(false),
-              EMSMoistureZoneLoadValue(0.0), HeatCoolMode(Furnaces::ModeOfOperation::Invalid), NumOfSpeedCooling(0), NumOfSpeedHeating(0),
-              IdleSpeedRatio(0.0), IdleVolumeAirRate(0.0), IdleMassFlowRate(0.0), FanVolFlow(0.0), CheckFanFlow(true),
-              HeatVolumeFlowRate(HVAC::MaxSpeedLevels, 0.0), HeatMassFlowRate(HVAC::MaxSpeedLevels, 0.0),
+            : FurnaceIndex(0), ControlZoneNum(0), ZoneSequenceCoolingNum(0),
+              ZoneSequenceHeatingNum(0), ActualDXCoilIndexForHXAssisted(0), 
+              fanType(HVAC::FanType::Invalid), FanIndex(0), 
+              LastMode(Furnaces::ModeOfOperation::Invalid), AirFlowControl(AirFlowControlConstFan::Invalid), fanPlace(HVAC::FanPlace::Invalid),
+              NodeNumOfControlledZone(0), CoolingConvergenceTolerance(0.0), HeatingConvergenceTolerance(0.0), DesignHeatingCapacity(0.0),
+              DesignCoolingCapacity(0.0), CoolingCoilSensDemand(0.0), HeatingCoilSensDemand(0.0), CoolingCoilLatentDemand(0.0),
+              DesignSuppHeatingCapacity(0.0), DesignFanVolFlowRate(0.0), DesignFanVolFlowRateEMSOverrideOn(false),
+              DesignFanVolFlowRateEMSOverrideValue(0.0), DesignMassFlowRate(0.0), MaxCoolAirVolFlow(0.0), MaxCoolAirVolFlowEMSOverrideOn(false),
+              MaxCoolAirVolFlowEMSOverrideValue(0.0), MaxHeatAirVolFlow(0.0), MaxHeatAirVolFlowEMSOverrideOn(false),
+              MaxHeatAirVolFlowEMSOverrideValue(0.0), MaxNoCoolHeatAirVolFlow(0.0), MaxNoCoolHeatAirVolFlowEMSOverrideOn(false),
+              MaxNoCoolHeatAirVolFlowEMSOverrideValue(0.0), MaxCoolAirMassFlow(0.0), MaxHeatAirMassFlow(0.0), MaxNoCoolHeatAirMassFlow(0.0),
+              MaxHeatCoilFluidFlow(0.0), MaxSuppCoilFluidFlow(0.0), ControlZoneMassFlowFrac(0.0), DesignMaxOutletTemp(9999.0), MdotFurnace(0.0),
+              FanPartLoadRatio(0.0), CompPartLoadRatio(0.0), CoolPartLoadRatio(0.0), HeatPartLoadRatio(0.0), MinOATCompressorCooling(0.0),
+              MinOATCompressorHeating(0.0), MaxOATSuppHeat(0.0), CondenserNodeNum(0), Humidistat(false), InitHeatPump(false),
+              DehumidControlType_Num(DehumidificationControlMode::None), LatentMaxIterIndex(0), LatentRegulaFalsiFailedIndex(0),
+              LatentRegulaFalsiFailedIndex2(0), SensibleMaxIterIndex(0), SensibleRegulaFalsiFailedIndex(0), WSHPHeatMaxIterIndex(0),
+              WSHPHeatRegulaFalsiFailedIndex(0), DXHeatingMaxIterIndex(0), DXHeatingRegulaFalsiFailedIndex(0), HeatingMaxIterIndex(0),
+              HeatingMaxIterIndex2(0), HeatingRegulaFalsiFailedIndex(0), ActualFanVolFlowRate(0.0), HeatingSpeedRatio(1.0), CoolingSpeedRatio(1.0),
+              NoHeatCoolSpeedRatio(1.0), ZoneInletNode(0), SenLoadLoss(0.0), LatLoadLoss(0.0), SensibleLoadMet(0.0), LatentLoadMet(0.0),
+              DehumidInducedHeatingDemandRate(0.0), CoilOutletNode(0), plantLoc{}, SuppPlantLoc{}, HotWaterCoilMaxIterIndex(0),
+              HotWaterCoilMaxIterIndex2(0), EMSOverrideSensZoneLoadRequest(false), EMSSensibleZoneLoadValue(0.0),
+              EMSOverrideMoistZoneLoadRequest(false), EMSMoistureZoneLoadValue(0.0), HeatCoolMode(Furnaces::ModeOfOperation::Invalid),
+              NumOfSpeedCooling(0), NumOfSpeedHeating(0), IdleSpeedRatio(0.0), IdleVolumeAirRate(0.0), IdleMassFlowRate(0.0), FanVolFlow(0.0),
+              CheckFanFlow(true), HeatVolumeFlowRate(HVAC::MaxSpeedLevels, 0.0), HeatMassFlowRate(HVAC::MaxSpeedLevels, 0.0),
               CoolVolumeFlowRate(HVAC::MaxSpeedLevels, 0.0), CoolMassFlowRate(HVAC::MaxSpeedLevels, 0.0),
-              MSHeatingSpeedRatio(HVAC::MaxSpeedLevels, 0.0), MSCoolingSpeedRatio(HVAC::MaxSpeedLevels, 0.0), bIsIHP(false), CompSpeedNum(0),
+              MSHeatingSpeedRatio(HVAC::MaxSpeedLevels, 0.0), MSCoolingSpeedRatio(HVAC::MaxSpeedLevels, 0.0), CompSpeedNum(0),
               CompSpeedRatio(0.0), ErrIndexCyc(0), ErrIndexVar(0), iterationCounter(0), iterationMode(0), FirstPass(true)
         {
         }
@@ -547,17 +560,15 @@ struct FurnacesData : BaseGlobalStruct
     bool EconomizerFlag = false;             // holds air loop economizer status
     int AirLoopPass = 0;                     // Number of air loop pass
     bool HPDehumidificationLoadFlag = false; // true if there is dehumidification load (heat pumps only)
-    Real64 TempSteamIn = 100.0;              // steam coil steam inlet temperature
     // starting add variables for variable speed water source heat pump
     Real64 SaveCompressorPLR = 0.0;  // holds compressor PLR from active DX coil
     std::string CurrentModuleObject; // Object type for getting and error messages
     int Iter = 0;                    // Iteration counter for CalcNewZoneHeatOnlyFlowRates
 
     std::string HeatingCoilName; // name of heating coil
-    std::string HeatingCoilType; // type of heating coil
 
     // Object Data
-    Array1D<Furnaces::FurnaceEquipConditions> Furnace;
+    Array1D<Furnaces::FurnaceEquipConditions> Furnaces;
 
     Array1D_bool MyEnvrnFlag;             // environment flag
     Array1D_bool MySecondOneTimeFlag;     // additional one time flag
@@ -610,13 +621,11 @@ struct FurnacesData : BaseGlobalStruct
         EconomizerFlag = false;
         AirLoopPass = 0;
         HPDehumidificationLoadFlag = false;
-        TempSteamIn = 100.0;
         SaveCompressorPLR = 0.0;
         CurrentModuleObject = "";
         Iter = 0;
         HeatingCoilName.clear();
-        HeatingCoilType.clear();
-        Furnace.clear();
+        Furnaces.clear();
 
         MyEnvrnFlag.clear();
         MySecondOneTimeFlag.clear();
diff --git a/src/EnergyPlus/GeneralRoutines.cc b/src/EnergyPlus/GeneralRoutines.cc
index 0bafaf45f1b..eeacf9f3cae 100644
--- a/src/EnergyPlus/GeneralRoutines.cc
+++ b/src/EnergyPlus/GeneralRoutines.cc
@@ -128,7 +128,7 @@ constexpr std::array<std::string_view, static_cast<int>(AirLoopHVACCompType::Num
 
 void ControlCompOutput(EnergyPlusData &state,
                        std::string const &CompName,                      // the component Name
-                       std::string const &CompType,                      // Type of component
+                       std::string_view const CompType,                      // Type of component
                        int &CompNum,                                     // Index of component in component array
                        bool const FirstHVACIteration,                    // flag for 1st HVAV iteration in the time step
                        Real64 const QZnReq,                              // zone load to be met
@@ -555,7 +555,7 @@ void ControlCompOutput(EnergyPlusData &state,
             ShowContinueError(state, format("... Actuated Node Mass Flow Rate ={:.9R} kg/s", state.dataLoopNodes->Node(ActuatedNode).MassFlowRate));
             ShowContinueErrorTimeStamp(state, "");
             ShowRecurringWarningErrorAtEnd(state,
-                                           "ControlCompOutput: Maximum iterations error for " + CompType + " = " + CompName,
+                                           format("ControlCompOutput: Maximum iterations error for {} = {}", CompType, CompName),
                                            CompErrIndex,
                                            std::abs((LoadMet - QZnReq) * 100.0 / Denom),
                                            std::abs((LoadMet - QZnReq) * 100.0 / Denom),
@@ -564,7 +564,7 @@ void ControlCompOutput(EnergyPlusData &state,
                                            "%");
             //}
             ShowRecurringWarningErrorAtEnd(state,
-                                           "ControlCompOutput: Maximum iterations error for " + CompType + " = " + CompName,
+                                           format("ControlCompOutput: Maximum iterations error for {} = {}", CompType, CompName),
                                            CompErrIndex,
                                            std::abs((LoadMet - QZnReq) * 100.0 / Denom),
                                            std::abs((LoadMet - QZnReq) * 100.0 / Denom),
@@ -756,6 +756,26 @@ void ValidateComponent(EnergyPlusData &state,
     }
 }
 
+bool ValidateComponent(EnergyPlusData &state,
+                       std::string_view CompType,   // Component Type (e.g. Chiller:Electric)
+                       std::string const &CompName, // Component Name (e.g. Big Chiller)
+                       std::string_view CallString  // Context of this pair -- for error message
+)
+{
+    int ItemNum = state.dataInputProcessing->inputProcessor->getObjectItemNum(state, std::string{CompType}, CompName);
+
+    if (ItemNum < 0) {
+        ShowSevereError(state, format("During {} Input, Invalid Component Type input={}", CallString, CompType));
+        ShowContinueError(state, format("Component name={}", CompName));
+        return false;
+    } else if (ItemNum == 0) {
+        ShowSevereError(state, format("During {} Input, Invalid Component Name input={}", CallString, CompName));
+        ShowContinueError(state, format("Component type={}", CompType));
+        return false;
+    }
+    return true;
+}
+
 void ValidateComponent(EnergyPlusData &state,
                        std::string_view CompType,      // Component Type (e.g. Chiller:Electric)
                        std::string const &CompValType, // Component "name" field type
@@ -796,6 +816,28 @@ void ValidateComponent(EnergyPlusData &state,
     }
 }
 
+bool ValidateComponent(EnergyPlusData &state,
+                       std::string_view CompType,      // Component Type (e.g. Chiller:Electric)
+                       std::string const &CompValType, // Component "name" field type
+                       std::string const &CompName,    // Component Name (e.g. Big Chiller)
+                       std::string_view CallString     // Context of this pair -- for error message
+)
+{
+    int ItemNum = state.dataInputProcessing->inputProcessor->getObjectItemNum(state, CompType, CompValType, CompName);
+
+    if (ItemNum < 0) {
+        ShowSevereError(state, format("During {} Input, Invalid Component Type input={}", CallString, CompType));
+        ShowContinueError(state, format("Component name={}", CompName));
+        return false; 
+    } else if (ItemNum == 0) {
+        ShowSevereError(state, format("During {} Input, Invalid Component Name input={}", CallString, CompName));
+        ShowContinueError(state, format("Component type={}", CompType));
+        return false; 
+    }
+
+    return true;
+}
+
 void CalcBasinHeaterPower(EnergyPlusData &state,
                           Real64 const Capacity,     // Basin heater capacity per degree C below setpoint (W/C)
                           Sched::Schedule *sched,    // basin heater schedule
diff --git a/src/EnergyPlus/GeneralRoutines.hh b/src/EnergyPlus/GeneralRoutines.hh
index 5866d84e676..3f0d5f69353 100644
--- a/src/EnergyPlus/GeneralRoutines.hh
+++ b/src/EnergyPlus/GeneralRoutines.hh
@@ -124,7 +124,7 @@ struct ZoneEquipControllerProps
 
 void ControlCompOutput(EnergyPlusData &state,
                        std::string const &CompName,                          // the component Name
-                       std::string const &CompType,                          // Type of component
+                       std::string_view const compType,                      // Type of component
                        int &CompNum,                                         // Index of component in component array
                        bool const FirstHVACIteration,                        // flag for 1st HVAV iteration in the time step
                        Real64 const QZnReq,                                  // zone load to be met
@@ -161,6 +161,12 @@ void CheckThisZoneForSizing(EnergyPlusData &state,
                             int const ZoneNum, // zone index to be checked
                             bool &ZoneWasSized);
 
+bool ValidateComponent(EnergyPlusData &state,
+                       std::string_view CompType,   // Component Type (e.g. Chiller:Electric)
+                       std::string const &CompName, // Component Name (e.g. Big Chiller)
+                       std::string_view CallString  // Context of this pair -- for error message
+);
+  
 void ValidateComponent(EnergyPlusData &state,
                        std::string_view CompType,   // Component Type (e.g. Chiller:Electric)
                        std::string const &CompName, // Component Name (e.g. Big Chiller)
@@ -168,6 +174,13 @@ void ValidateComponent(EnergyPlusData &state,
                        std::string_view CallString  // Context of this pair -- for error message
 );
 
+bool ValidateComponent(EnergyPlusData &state,
+                       std::string_view CompType,      // Component Type (e.g. Chiller:Electric)
+                       std::string const &CompValType, // Component "name" field type
+                       std::string const &CompName,    // Component Name (e.g. Big Chiller)
+                       std::string_view CallString     // Context of this pair -- for error message
+);
+  
 void ValidateComponent(EnergyPlusData &state,
                        std::string_view CompType,      // Component Type (e.g. Chiller:Electric)
                        std::string const &CompValType, // Component "name" field type
diff --git a/src/EnergyPlus/HVACDXHeatPumpSystem.cc b/src/EnergyPlus/HVACDXHeatPumpSystem.cc
index ce71e6ec18b..9f1d238a733 100644
--- a/src/EnergyPlus/HVACDXHeatPumpSystem.cc
+++ b/src/EnergyPlus/HVACDXHeatPumpSystem.cc
@@ -127,8 +127,6 @@ namespace HVACDXHeatPumpSystem {
         int DXSystemNum;      // Index to CoilSystem:Heating:DX object
         Real64 AirMassFlow;   // DX System air mass flow rate
 
-        auto &DXHeatPumpSystem(state.dataHVACDXHeatPumpSys->DXHeatPumpSystem);
-
         // Obtains and Allocates DX Cooling System related parameters from input file
         if (state.dataHVACDXHeatPumpSys->GetInputFlag) { // First time subroutine has been entered
             // Get the DXCoolingSystem input
@@ -140,7 +138,7 @@ namespace HVACDXHeatPumpSystem {
 
         // Find the correct DXSystemNumber
         if (CompIndex == 0) {
-            DXSystemNum = Util::FindItemInList(DXHeatPumpSystemName, DXHeatPumpSystem);
+            DXSystemNum = Util::FindItemInList(DXHeatPumpSystemName, state.dataHVACDXHeatPumpSys->DXHeatPumpSystem);
             if (DXSystemNum == 0) {
                 ShowFatalError(state, format("SimDXHeatPumpSystem: DXUnit not found={}", DXHeatPumpSystemName));
             }
@@ -155,12 +153,12 @@ namespace HVACDXHeatPumpSystem {
                                       DXHeatPumpSystemName));
             }
             if (state.dataHVACDXHeatPumpSys->CheckEquipName(DXSystemNum)) {
-                if (DXHeatPumpSystemName != DXHeatPumpSystem(DXSystemNum).Name) {
+                if (DXHeatPumpSystemName != state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum).Name) {
                     ShowFatalError(state,
                                    format("SimDXHeatPumpSystem: Invalid CompIndex passed={}, DX Unit name={}, stored DX Unit Name for that index={}",
                                           DXSystemNum,
                                           DXHeatPumpSystemName,
-                                          DXHeatPumpSystem(DXSystemNum).Name));
+                                          state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum).Name));
                 }
                 state.dataHVACDXHeatPumpSys->CheckEquipName(DXSystemNum) = false;
             }
@@ -177,40 +175,40 @@ namespace HVACDXHeatPumpSystem {
         ControlDXHeatingSystem(state, DXSystemNum, FirstHVACIteration);
 
         // simulate DX Heating System
-        CompName = DXHeatPumpSystem(DXSystemNum).HeatPumpCoilName;
-
-        switch (DXHeatPumpSystem(DXSystemNum).HeatPumpCoilType_Num) {
-        case HVAC::CoilDX_HeatingEmpirical: { // COIL:DX:COOLINGBYPASSFACTOREMPIRICAL
+        auto &dxhp = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum);
+        
+        switch (dxhp.dxCoilType) {
+        case HVAC::CoilType::HeatingDXSingleSpeed: { // COIL:DX:COOLINGBYPASSFACTOREMPIRICAL
             SimDXCoil(state,
-                      CompName,
+                      dxhp.DXCoilNum,
                       HVAC::CompressorOp::On,
                       FirstHVACIteration,
-                      DXHeatPumpSystem(DXSystemNum).HeatPumpCoilIndex,
-                      DXHeatPumpSystem(DXSystemNum).fanOp,
-                      DXHeatPumpSystem(DXSystemNum).PartLoadFrac);
+                      dxhp.fanOp,
+                      dxhp.PartLoadFrac);
         } break;
-        case HVAC::Coil_HeatingAirToAirVariableSpeed: { // Coil:Heating:DX:VariableSpeed
+          
+        case HVAC::CoilType::HeatingDXVariableSpeed: { // Coil:Heating:DX:VariableSpeed
             SimVariableSpeedCoils(state,
-                                  CompName,
-                                  DXHeatPumpSystem(DXSystemNum).HeatPumpCoilIndex,
-                                  DXHeatPumpSystem(DXSystemNum).fanOp,
+                                  dxhp.DXCoilName,
+                                  dxhp.DXCoilNum,
+                                  dxhp.fanOp,
                                   HVAC::CompressorOp::On,
-                                  DXHeatPumpSystem(DXSystemNum).PartLoadFrac,
-                                  DXHeatPumpSystem(DXSystemNum).SpeedNum,
-                                  DXHeatPumpSystem(DXSystemNum).SpeedRatio,
+                                  dxhp.PartLoadFrac,
+                                  dxhp.SpeedNum,
+                                  dxhp.SpeedRatio,
                                   state.dataHVACDXHeatPumpSys->QZnReq,
                                   state.dataHVACDXHeatPumpSys->QLatReq,
                                   state.dataHVACDXHeatPumpSys->OnOffAirFlowRatio);
         } break;
         default: {
-            ShowFatalError(state, format("SimDXCoolingSystem: Invalid DX Heating System/Coil={}", DXHeatPumpSystem(DXSystemNum).HeatPumpCoilType));
+          ShowFatalError(state, format("SimDXCoolingSystem: Invalid DX Heating System/Coil={}", HVAC::coilTypeNames[(int)dxhp.dxCoilType]));
         } break;
         }
         // set econo lockout flag
         // set econo lockout flag
         if (AirLoopNum != -1) { // IF the sysem is not an equipment of outdoor air unit
 
-            if ((DXHeatPumpSystem(DXSystemNum).PartLoadFrac > 0.0) &&
+            if ((dxhp.PartLoadFrac > 0.0) &&
                 state.dataAirLoop->AirLoopControlInfo(AirLoopNum).CanLockoutEconoWithCompressor) {
                 state.dataAirLoop->AirLoopControlInfo(AirLoopNum).ReqstEconoLockoutWithCompressor = true;
             } else {
@@ -219,8 +217,8 @@ namespace HVACDXHeatPumpSystem {
         }
 
         if (present(QTotOut)) {
-            int InletNodeNum = DXHeatPumpSystem(DXSystemNum).DXHeatPumpCoilInletNodeNum;
-            int OutletNodeNum = DXHeatPumpSystem(DXSystemNum).DXHeatPumpCoilOutletNodeNum;
+            int InletNodeNum = dxhp.DXCoilInNodeNum;
+            int OutletNodeNum = dxhp.DXCoilOutNodeNum;
             AirMassFlow = state.dataLoopNodes->Node(OutletNodeNum).MassFlowRate;
             QTotOut = AirMassFlow * (state.dataLoopNodes->Node(InletNodeNum).Enthalpy - state.dataLoopNodes->Node(OutletNodeNum).Enthalpy);
         }
@@ -248,19 +246,14 @@ namespace HVACDXHeatPumpSystem {
         // Using/Aliasing
         using BranchNodeConnections::SetUpCompSets;
         using BranchNodeConnections::TestCompSet;
-        using DXCoils::GetCoilInletNode;
-        using DXCoils::GetCoilOutletNode;
-        using DXCoils::SetCoilSystemHeatingDXFlag;
-        using VariableSpeedCoils::GetCoilInletNodeVariableSpeed;
-        using VariableSpeedCoils::GetCoilOutletNodeVariableSpeed;
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         int NumAlphas;
         int NumNums;
         int IOStat;
         static constexpr std::string_view RoutineName("GetDXHeatPumpSystemInput: "); // include trailing blank space
+
         static constexpr std::string_view routineName = "GetDXHeatPumpSystemInput";
-        bool IsNotOK; // Flag to verify name
         int DXHeatSysNum;
         std::string CurrentModuleObject; // for ease in getting objects
         Array1D_string Alphas;           // Alpha input items for object
@@ -270,14 +263,14 @@ namespace HVACDXHeatPumpSystem {
         Array1D_bool lAlphaBlanks;       // Logical array, alpha field input BLANK = .TRUE.
         Array1D_bool lNumericBlanks;     // Logical array, numeric field input BLANK = .TRUE.
 
-        auto &DXHeatPumpSystem(state.dataHVACDXHeatPumpSys->DXHeatPumpSystem);
+        bool ErrorsFound = false;
 
         CurrentModuleObject = "CoilSystem:Heating:DX";
         // Update Num in state and make local convenience copy
         int NumDXHeatPumpSystems = state.dataHVACDXHeatPumpSys->NumDXHeatPumpSystems =
             state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject);
 
-        DXHeatPumpSystem.allocate(NumDXHeatPumpSystems);
+        state.dataHVACDXHeatPumpSys->DXHeatPumpSystem.allocate(NumDXHeatPumpSystems);
         state.dataHVACDXHeatPumpSys->CheckEquipName.dimension(NumDXHeatPumpSystems, true);
 
         state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
@@ -307,108 +300,86 @@ namespace HVACDXHeatPumpSystem {
                                                                      cNumericFields);
 
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-            DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpSystemType = CurrentModuleObject; // push Object Name into data array
-            DXHeatPumpSystem(DXHeatSysNum).Name = Alphas(1);
+
+            auto &dxhp = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXHeatSysNum);
+            dxhp.DXHeatPumpSystemType = CurrentModuleObject; // push Object Name into data array
+            dxhp.Name = Alphas(1);
 
             if (lAlphaBlanks(2)) {
-                DXHeatPumpSystem(DXHeatSysNum).availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((DXHeatPumpSystem(DXHeatSysNum).availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                dxhp.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((dxhp.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
-                state.dataHVACDXHeatPumpSys->ErrorsFound = true;
+                ErrorsFound = true;
             }
 
-            if (Util::SameString(Alphas(3), "Coil:Heating:DX:SingleSpeed")) {
-
-                DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType = Alphas(3);
-                DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
-
-                DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName = Alphas(4);
-            } else if (Util::SameString(Alphas(3), "Coil:Heating:DX:VariableSpeed")) {
-
-                DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType = Alphas(3);
-                DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType_Num = HVAC::Coil_HeatingAirToAirVariableSpeed;
-
-                DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName = Alphas(4);
-
-            } else {
-                ShowSevereError(state, format("Invalid entry for {} :{}", cAlphaFields(3), Alphas(3)));
-                ShowContinueError(state, format("In {}=\"{}\".", CurrentModuleObject, DXHeatPumpSystem(DXHeatSysNum).Name));
-                state.dataHVACDXHeatPumpSys->ErrorsFound = true;
-            }
+            dxhp.dxCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(3)));
+            dxhp.DXCoilName = Alphas(4);
+
+            if (dxhp.dxCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
+                dxhp.DXCoilNum = DXCoils::GetCoilIndex(state, dxhp.DXCoilName);
+                if (dxhp.DXCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(4), dxhp.DXCoilName);
+                    ErrorsFound = true;
+                } else {
+                    dxhp.DXCoilInNodeNum = DXCoils::GetCoilAirInletNode(state, dxhp.DXCoilNum);
+                    dxhp.DXCoilOutNodeNum = DXCoils::GetCoilAirOutletNode(state, dxhp.DXCoilNum);
+                }
 
-            if (DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilInletNodeNum =
-                    GetCoilInletNodeVariableSpeed(state,
-                                                  DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType,
-                                                  DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName,
-                                                  state.dataHVACDXHeatPumpSys->ErrorsFound);
-                DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilOutletNodeNum =
-                    GetCoilOutletNodeVariableSpeed(state,
-                                                   DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType,
-                                                   DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName,
-                                                   state.dataHVACDXHeatPumpSys->ErrorsFound);
+            } else if (dxhp.dxCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+                dxhp.DXCoilNum = VariableSpeedCoils::GetCoilIndex(state, dxhp.DXCoilName);
+                if (dxhp.DXCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(4), dxhp.DXCoilName);
+                    ErrorsFound = true;
+                } else {
+                    dxhp.DXCoilInNodeNum = VariableSpeedCoils::GetCoilAirInletNode(state, dxhp.DXCoilNum);
+                    dxhp.DXCoilOutNodeNum = VariableSpeedCoils::GetCoilAirOutletNode(state, dxhp.DXCoilNum);
+                }
             } else {
-                DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilInletNodeNum = GetCoilInletNode(state,
-                                                                                             DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType,
-                                                                                             DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName,
-                                                                                             state.dataHVACDXHeatPumpSys->ErrorsFound);
-
-                DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilOutletNodeNum = GetCoilOutletNode(state,
-                                                                                               DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType,
-                                                                                               DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName,
-                                                                                               state.dataHVACDXHeatPumpSys->ErrorsFound);
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(3), Alphas(3));
+                ErrorsFound = true; // Why is this a state variable?
             }
 
             // Coil air-side outlet node is the control node
-            DXHeatPumpSystem(DXHeatSysNum).DXSystemControlNodeNum = DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilOutletNodeNum;
+            dxhp.DXSystemControlNodeNum = dxhp.DXCoilOutNodeNum;
 
             TestCompSet(state,
                         CurrentModuleObject,
-                        DXHeatPumpSystem(DXHeatSysNum).Name,
-                        state.dataLoopNodes->NodeID(DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilInletNodeNum),
-                        state.dataLoopNodes->NodeID(DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilOutletNodeNum),
+                        dxhp.Name,
+                        state.dataLoopNodes->NodeID(dxhp.DXCoilInNodeNum),
+                        state.dataLoopNodes->NodeID(dxhp.DXCoilOutNodeNum),
                         "Air Nodes");
 
-            ValidateComponent(state,
-                              DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType,
-                              DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName,
-                              IsNotOK,
-                              CurrentModuleObject);
-            if (IsNotOK) {
-                ShowContinueError(state, format("In {} = \"{}\".", CurrentModuleObject, DXHeatPumpSystem(DXHeatSysNum).Name));
-                state.dataHVACDXHeatPumpSys->ErrorsFound = true;
-            }
-
             SetUpCompSets(state,
-                          DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpSystemType,
-                          DXHeatPumpSystem(DXHeatSysNum).Name,
-                          DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType,
-                          DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName,
-                          state.dataLoopNodes->NodeID(DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilInletNodeNum),
-                          state.dataLoopNodes->NodeID(DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilOutletNodeNum));
+                          dxhp.DXHeatPumpSystemType,
+                          dxhp.Name,
+                          HVAC::coilTypeNames[(int)dxhp.dxCoilType],
+                          dxhp.DXCoilName,
+                          state.dataLoopNodes->NodeID(dxhp.DXCoilInNodeNum),
+                          state.dataLoopNodes->NodeID(dxhp.DXCoilOutNodeNum));
 
             // Supply air fan operating mode defaulted to constant fan cycling coil/compressor
-            DXHeatPumpSystem(DXHeatSysNum).fanOp = HVAC::FanOp::Continuous;
+            dxhp.fanOp = HVAC::FanOp::Continuous;
 
-            if (DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType_Num != HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                SetCoilSystemHeatingDXFlag(state, DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilType, DXHeatPumpSystem(DXHeatSysNum).HeatPumpCoilName);
+            if (dxhp.dxCoilType != HVAC::CoilType::HeatingDXVariableSpeed) {
+                DXCoils::SetCoilSystemHeatingDXFlag(state, dxhp.DXCoilNum);
             }
 
         } // End of the DX System Loop
 
-        if (state.dataHVACDXHeatPumpSys->ErrorsFound) {
+        if (ErrorsFound) {
             ShowFatalError(state, format("{}Errors found in input.  Program terminates.", RoutineName));
         }
 
         for (DXHeatSysNum = 1; DXHeatSysNum <= NumDXHeatPumpSystems; ++DXHeatSysNum) {
             // Setup Report variables for the DXHeatingSystem that is not reported in the components themselves
+            auto &dxhp = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXHeatSysNum);
             SetupOutputVariable(state,
                                 "Coil System Part Load Ratio",
                                 Constant::Units::None,
-                                DXHeatPumpSystem(DXHeatSysNum).PartLoadFrac,
+                                dxhp.PartLoadFrac,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                DXHeatPumpSystem(DXHeatSysNum).Name);
+                                dxhp.Name);
         }
 
         Alphas.deallocate();
@@ -466,8 +437,8 @@ namespace HVACDXHeatPumpSystem {
 
         if (!state.dataGlobal->SysSizingCalc && state.dataHVACDXHeatPumpSys->MySetPointCheckFlag && DoSetPointTest) {
             for (int DXSysIndex = 1; DXSysIndex <= NumDXHeatPumpSystems; ++DXSysIndex) {
-                auto &DXHeatPumpSystem = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSysIndex);
-                ControlNode = DXHeatPumpSystem.DXSystemControlNodeNum;
+                auto &dxhp = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSysIndex);
+                ControlNode = dxhp.DXSystemControlNodeNum;
                 if (ControlNode > 0) {
                     if (AirLoopNum == -1) {                                                      // Outdoor Air Unit
                         state.dataLoopNodes->Node(ControlNode).TempSetPoint = OAUCoilOutletTemp; // Set the coil outlet temperature
@@ -477,8 +448,8 @@ namespace HVACDXHeatPumpSystem {
                             if (!state.dataGlobal->AnyEnergyManagementSystemInModel) {
                                 ShowSevereError(state,
                                                 format("{}: Missing temperature setpoint for DX unit= {}",
-                                                       DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                       DXHeatPumpSystem.Name));
+                                                       dxhp.DXHeatPumpSystemType,
+                                                       dxhp.Name));
                                 ShowContinueError(state, "  use a Set Point Manager to establish a setpoint at the unit control node.");
                                 state.dataHVACGlobal->SetPointErrorFlag = true;
                             } else {
@@ -486,8 +457,8 @@ namespace HVACDXHeatPumpSystem {
                                 if (state.dataHVACGlobal->SetPointErrorFlag) {
                                     ShowSevereError(state,
                                                     format("{}: Missing temperature setpoint for DX unit= {}",
-                                                           DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                           DXHeatPumpSystem.Name));
+                                                           dxhp.DXHeatPumpSystemType,
+                                                           dxhp.Name));
                                     ShowContinueError(state, "  use a Set Point Manager to establish a setpoint at the unit control node.");
                                     ShowContinueError(state,
                                                       "  or use an EMS actuator to establish a temperature setpoint at the unit control node.");
@@ -500,15 +471,16 @@ namespace HVACDXHeatPumpSystem {
             state.dataHVACDXHeatPumpSys->MySetPointCheckFlag = false;
         }
 
+        auto &dxhp = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum);
         // These initializations are done every iteration
         if (AirLoopNum == -1) { // This IF-Then routine is just for ZoneHVAC:OUTDOORAIRUNIT
 
-            state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum).DesiredOutletTemp = OAUCoilOutletTemp;
+            dxhp.DesiredOutletTemp = OAUCoilOutletTemp;
 
         } else { // Not Outdoor Air Unit
-            ControlNode = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum).DXSystemControlNodeNum;
+            ControlNode = dxhp.DXSystemControlNodeNum;
             state.dataHVACDXHeatPumpSys->EconomizerFlag = state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive;
-            state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum).DesiredOutletTemp = state.dataLoopNodes->Node(ControlNode).TempSetPoint;
+            dxhp.DesiredOutletTemp = state.dataLoopNodes->Node(ControlNode).TempSetPoint;
         }
     }
 
@@ -553,7 +525,6 @@ namespace HVACDXHeatPumpSystem {
         Real64 constexpr Acc(1.e-3); // Accuracy of solver result
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        std::string CompName; // Name of the DX cooling coil
         Real64 NoOutput;      // Sensible capacity (outlet - inlet) when the compressor is off
         Real64 FullOutput;    // Sensible capacity (outlet - inlet) when the compressor is on
         Real64 ReqOutput;     // Sensible capacity (outlet - inlet) required to meet load or set point temperature
@@ -579,16 +550,15 @@ namespace HVACDXHeatPumpSystem {
         int I;                    // interation increment
         Real64 SpeedRatio;        // speed ratio between two neighboring speeds
 
-        auto &DXHeatPumpSystem = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum);
+        auto &dxhp = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXSystemNum);
 
         // Set local variables
         // Retrieve the load on the controlled zone
-        OutletNode = DXHeatPumpSystem.DXHeatPumpCoilOutletNodeNum;
-        InletNode = DXHeatPumpSystem.DXHeatPumpCoilInletNodeNum;
-        ControlNode = DXHeatPumpSystem.DXSystemControlNodeNum;
-        DesOutTemp = DXHeatPumpSystem.DesiredOutletTemp;
-        CompName = DXHeatPumpSystem.HeatPumpCoilName;
-        fanOp = DXHeatPumpSystem.fanOp;
+        OutletNode = dxhp.DXCoilOutNodeNum;
+        InletNode = dxhp.DXCoilInNodeNum;
+        ControlNode = dxhp.DXSystemControlNodeNum;
+        DesOutTemp = dxhp.DesiredOutletTemp;
+        fanOp = dxhp.fanOp;
 
         PartLoadFrac = 0.0;
 
@@ -606,17 +576,17 @@ namespace HVACDXHeatPumpSystem {
         SpeedRatio = 0.0;
 
         // If there is a fault of coil SAT Sensor
-        if (DXHeatPumpSystem.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
+        if (dxhp.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
             (!state.dataGlobal->KickOffSimulation)) {
             // calculate the sensor offset using fault information
-            int FaultIndex = DXHeatPumpSystem.FaultyCoilSATIndex;
-            DXHeatPumpSystem.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
+            int FaultIndex = dxhp.FaultyCoilSATIndex;
+            dxhp.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
             // update the DesOutTemp
-            DesOutTemp -= DXHeatPumpSystem.FaultyCoilSATOffset;
+            DesOutTemp -= dxhp.FaultyCoilSATOffset;
         }
 
         // If DXHeatingSystem is scheduled on and there is flow
-        if ((DXHeatPumpSystem.availSched->getCurrentVal() > 0.0) && (state.dataLoopNodes->Node(InletNode).MassFlowRate > MinAirMassFlow)) {
+        if ((dxhp.availSched->getCurrentVal() > 0.0) && (state.dataLoopNodes->Node(InletNode).MassFlowRate > MinAirMassFlow)) {
 
             // Determine if there is a sensible load on this system
             if ((state.dataLoopNodes->Node(InletNode).Temp < state.dataLoopNodes->Node(ControlNode).TempSetPoint) &&
@@ -629,13 +599,13 @@ namespace HVACDXHeatPumpSystem {
                 {
                     Real64 TempOut1;
 
-                    switch (DXHeatPumpSystem.HeatPumpCoilType_Num) {
-                    case HVAC::CoilDX_HeatingEmpirical: { // Coil:Heating:DX:SingleSpeed
+                    switch (dxhp.dxCoilType) {
+                    case HVAC::CoilType::HeatingDXSingleSpeed: { // Coil:Heating:DX:SingleSpeed
 
                         // Get no load result
                         PartLoadFrac = 0.0;
                         SimDXCoil(
-                            state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, DXHeatPumpSystem.HeatPumpCoilIndex, fanOp, PartLoadFrac);
+                            state, dxhp.DXCoilName, HVAC::CompressorOp::On, FirstHVACIteration, dxhp.DXCoilNum, fanOp, PartLoadFrac);
                         NoOutput = state.dataLoopNodes->Node(InletNode).MassFlowRate *
                                    (PsyHFnTdbW(state.dataLoopNodes->Node(OutletNode).Temp, state.dataLoopNodes->Node(OutletNode).HumRat) -
                                     PsyHFnTdbW(state.dataLoopNodes->Node(InletNode).Temp, state.dataLoopNodes->Node(OutletNode).HumRat));
@@ -643,7 +613,7 @@ namespace HVACDXHeatPumpSystem {
                         // Get full load result
                         PartLoadFrac = 1.0;
                         SimDXCoil(
-                            state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, DXHeatPumpSystem.HeatPumpCoilIndex, fanOp, PartLoadFrac);
+                            state, dxhp.DXCoilName, HVAC::CompressorOp::On, FirstHVACIteration, dxhp.DXCoilNum, fanOp, PartLoadFrac);
 
                         FullOutput = state.dataLoopNodes->Node(InletNode).MassFlowRate *
                                      (PsyHFnTdbW(state.dataLoopNodes->Node(OutletNode).Temp, state.dataLoopNodes->Node(InletNode).HumRat) -
@@ -665,7 +635,7 @@ namespace HVACDXHeatPumpSystem {
                             //           OutletTempDXCoil is the full capacity outlet temperature at PartLoadFrac = 1 from the CALL above. If this
                             //           temp is greater than the desired outlet temp, then run the compressor at PartLoadFrac = 1, otherwise find the
                             //           operating PLR.
-                            OutletTempDXCoil = state.dataDXCoils->DXCoilOutletTemp(DXHeatPumpSystem.HeatPumpCoilIndex);
+                            OutletTempDXCoil = state.dataDXCoils->DXCoilOutletTemp(dxhp.DXCoilNum);
                             if (OutletTempDXCoil < DesOutTemp) {
                                 PartLoadFrac = 1.0;
                             } else {
@@ -673,14 +643,14 @@ namespace HVACDXHeatPumpSystem {
                                     PartLoadFrac = (DesOutTemp - state.dataLoopNodes->Node(InletNode).Temp) /
                                                    (TempOut1 - state.dataLoopNodes->Node(InletNode).Temp);
                                     SimDXCoil(state,
-                                              CompName,
+                                              dxhp.DXCoilName,
                                               HVAC::CompressorOp::On,
                                               FirstHVACIteration,
-                                              DXHeatPumpSystem.HeatPumpCoilIndex,
+                                              dxhp.DXCoilNum,
                                               fanOp,
                                               PartLoadFrac);
                                 } else {
-                                    int coilIndex = DXHeatPumpSystem.HeatPumpCoilIndex;
+                                    int coilIndex = dxhp.DXCoilNum;
                                     auto f = [&state, coilIndex, DesOutTemp](Real64 const PartLoadFrac) {
                                         DXCoils::CalcDXHeatingCoil(state, coilIndex, PartLoadFrac, HVAC::FanOp::Continuous, 1.0);
                                         Real64 OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(coilIndex);
@@ -690,13 +660,13 @@ namespace HVACDXHeatPumpSystem {
                                     SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                                     if (SolFla == -1) {
                                         if (!state.dataGlobal->WarmupFlag) {
-                                            if (DXHeatPumpSystem.DXCoilSensPLRIter < 1) {
-                                                ++DXHeatPumpSystem.DXCoilSensPLRIter;
+                                            if (dxhp.DXCoilSensPLRIter < 1) {
+                                                ++dxhp.DXCoilSensPLRIter;
                                                 ShowWarningError(
                                                     state,
                                                     format("{} - Iteration limit exceeded calculating DX unit sensible part-load ratio for unit = {}",
-                                                           DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                           DXHeatPumpSystem.Name));
+                                                           dxhp.DXHeatPumpSystemType,
+                                                           dxhp.Name));
                                                 ShowContinueError(state, format("Estimated part-load ratio  = {:.3R}", (ReqOutput / FullOutput)));
                                                 ShowContinueError(state, format("Calculated part-load ratio = {:.3R}", PartLoadFrac));
                                                 ShowContinueErrorTimeStamp(
@@ -704,11 +674,11 @@ namespace HVACDXHeatPumpSystem {
                                                     "The calculated part-load ratio will be used and the simulation continues. Occurrence info:");
                                             } else {
                                                 ShowRecurringWarningErrorAtEnd(state,
-                                                                               DXHeatPumpSystem.DXHeatPumpSystemType + " \"" + DXHeatPumpSystem.Name +
+                                                                               dxhp.DXHeatPumpSystemType + " \"" + dxhp.Name +
                                                                                    "\" - Iteration limit exceeded calculating sensible part-load "
                                                                                    "ratio error continues. Sensible "
                                                                                    "PLR statistics follow.",
-                                                                               DXHeatPumpSystem.DXCoilSensPLRIterIndex,
+                                                                               dxhp.DXCoilSensPLRIterIndex,
                                                                                PartLoadFrac,
                                                                                PartLoadFrac);
                                             }
@@ -716,13 +686,13 @@ namespace HVACDXHeatPumpSystem {
                                     } else if (SolFla == -2) {
                                         PartLoadFrac = ReqOutput / FullOutput;
                                         if (!state.dataGlobal->WarmupFlag) {
-                                            if (DXHeatPumpSystem.DXCoilSensPLRFail < 1) {
-                                                ++DXHeatPumpSystem.DXCoilSensPLRFail;
+                                            if (dxhp.DXCoilSensPLRFail < 1) {
+                                                ++dxhp.DXCoilSensPLRFail;
                                                 ShowWarningError(state,
                                                                  format("{} - DX unit sensible part-load ratio calculation failed: part-load ratio "
                                                                         "limits exceeded, for unit = {}",
-                                                                        DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                                        DXHeatPumpSystem.Name));
+                                                                        dxhp.DXHeatPumpSystemType,
+                                                                        dxhp.Name));
                                                 ShowContinueError(state, format("Estimated part-load ratio = {:.3R}", PartLoadFrac));
                                                 ShowContinueErrorTimeStamp(
                                                     state,
@@ -730,10 +700,10 @@ namespace HVACDXHeatPumpSystem {
                                             } else {
                                                 ShowRecurringWarningErrorAtEnd(
                                                     state,
-                                                    DXHeatPumpSystem.DXHeatPumpSystemType + " \"" + DXHeatPumpSystem.Name +
+                                                    dxhp.DXHeatPumpSystemType + " \"" + dxhp.Name +
                                                         "\" - DX unit sensible part-load ratio calculation failed error continues. Sensible PLR "
                                                         "statistics follow.",
-                                                    DXHeatPumpSystem.DXCoilSensPLRFailIndex,
+                                                    dxhp.DXCoilSensPLRFailIndex,
                                                     PartLoadFrac,
                                                     PartLoadFrac);
                                             }
@@ -749,7 +719,8 @@ namespace HVACDXHeatPumpSystem {
                             PartLoadFrac = 0.0;
                         }
                     } break;
-                    case HVAC::Coil_HeatingAirToAirVariableSpeed: {
+                      
+                    case HVAC::CoilType::HeatingDXVariableSpeed: {
                         // variable-speed air-to-air heating coil, begin -------------------------
                         // Get no load result
                         PartLoadFrac = 0.0;
@@ -760,8 +731,8 @@ namespace HVACDXHeatPumpSystem {
                         SpeedRatio = 0.0;
 
                         SimVariableSpeedCoils(state,
-                                              CompName,
-                                              DXHeatPumpSystem.HeatPumpCoilIndex,
+                                              dxhp.DXCoilName,
+                                              dxhp.DXCoilNum,
                                               fanOp,
                                               HVAC::CompressorOp::On,
                                               PartLoadFrac,
@@ -771,7 +742,7 @@ namespace HVACDXHeatPumpSystem {
                                               QLatReq,
                                               OnOffAirFlowRatio);
 
-                        VSCoilIndex = DXHeatPumpSystem.HeatPumpCoilIndex;
+                        VSCoilIndex = dxhp.DXCoilNum;
                         NumOfSpeeds = state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilIndex).NumOfSpeeds;
 
                         NoOutput = state.dataLoopNodes->Node(InletNode).MassFlowRate *
@@ -785,7 +756,7 @@ namespace HVACDXHeatPumpSystem {
                         SpeedRatio = 1.0;
                         QZnReq = 0.001; // to indicate the coil is running
                         SimVariableSpeedCoils(state,
-                                              CompName,
+                                              dxhp.DXCoilName,
                                               VSCoilIndex,
                                               fanOp,
                                               HVAC::CompressorOp::On,
@@ -830,8 +801,8 @@ namespace HVACDXHeatPumpSystem {
                                 SpeedRatio = 1.0;
                                 QZnReq = 0.001; // to indicate the coil is running
                                 SimVariableSpeedCoils(state,
-                                                      CompName,
-                                                      VSCoilIndex,
+                                                      dxhp.DXCoilName,
+                                                      dxhp.DXCoilNum,
                                                       fanOp,
                                                       HVAC::CompressorOp::On,
                                                       PartLoadFrac,
@@ -851,8 +822,8 @@ namespace HVACDXHeatPumpSystem {
                                     for (I = 2; I <= NumOfSpeeds; ++I) {
                                         SpeedNum = I;
                                         SimVariableSpeedCoils(state,
-                                                              CompName,
-                                                              VSCoilIndex,
+                                                              dxhp.DXCoilName,
+                                                              dxhp.DXCoilNum,
                                                               fanOp,
                                                               HVAC::CompressorOp::On,
                                                               PartLoadFrac,
@@ -873,8 +844,8 @@ namespace HVACDXHeatPumpSystem {
                                     if (state.dataGlobal->DoCoilDirectSolutions) {
                                         SpeedRatio = (DesOutTemp - TempOut1) / (TempSpeedOut - TempOut1);
                                         SimVariableSpeedCoils(state,
-                                                              CompName,
-                                                              VSCoilIndex,
+                                                              dxhp.DXCoilName,
+                                                              dxhp.DXCoilNum,
                                                               fanOp,
                                                               HVAC::CompressorOp::On,
                                                               PartLoadFrac,
@@ -892,13 +863,13 @@ namespace HVACDXHeatPumpSystem {
 
                                         if (SolFla == -1) {
                                             if (!state.dataGlobal->WarmupFlag) {
-                                                if (DXHeatPumpSystem.DXCoilSensPLRIter < 1) {
-                                                    ++DXHeatPumpSystem.DXCoilSensPLRIter;
+                                                if (dxhp.DXCoilSensPLRIter < 1) {
+                                                    ++dxhp.DXCoilSensPLRIter;
                                                     ShowWarningError(state,
                                                                      format("{} - Iteration limit exceeded calculating DX unit sensible part-load "
                                                                             "ratio for unit = {}",
-                                                                            DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                                            DXHeatPumpSystem.Name));
+                                                                            dxhp.DXHeatPumpSystemType,
+                                                                            dxhp.Name));
                                                     ShowContinueError(state, format("Estimated part-load ratio  = {:.3R}", (ReqOutput / FullOutput)));
                                                     ShowContinueError(state, format("Calculated part-load ratio = {:.3R}", PartLoadFrac));
                                                     ShowContinueErrorTimeStamp(
@@ -907,10 +878,10 @@ namespace HVACDXHeatPumpSystem {
                                                 } else {
                                                     ShowRecurringWarningErrorAtEnd(
                                                         state,
-                                                        DXHeatPumpSystem.DXHeatPumpSystemType + " \"" + DXHeatPumpSystem.Name +
+                                                        dxhp.DXHeatPumpSystemType + " \"" + dxhp.Name +
                                                             "\" - Iteration limit exceeded calculating sensible part-load ratio error continues. "
                                                             "Sensible PLR statistics follow.",
-                                                        DXHeatPumpSystem.DXCoilSensPLRIterIndex,
+                                                        dxhp.DXCoilSensPLRIterIndex,
                                                         PartLoadFrac,
                                                         PartLoadFrac);
                                                 }
@@ -918,13 +889,13 @@ namespace HVACDXHeatPumpSystem {
                                         } else if (SolFla == -2) {
                                             PartLoadFrac = ReqOutput / FullOutput;
                                             if (!state.dataGlobal->WarmupFlag) {
-                                                if (DXHeatPumpSystem.DXCoilSensPLRFail < 1) {
-                                                    ++DXHeatPumpSystem.DXCoilSensPLRFail;
+                                                if (dxhp.DXCoilSensPLRFail < 1) {
+                                                    ++dxhp.DXCoilSensPLRFail;
                                                     ShowWarningError(state,
                                                                      format("{} - DX unit sensible part-load ratio calculation failed: part-load "
                                                                             "ratio limits exceeded, for unit = {}",
-                                                                            DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                                            DXHeatPumpSystem.Name));
+                                                                            dxhp.DXHeatPumpSystemType,
+                                                                            dxhp.Name));
                                                     ShowContinueError(state, format("Estimated part-load ratio = {:.3R}", PartLoadFrac));
                                                     ShowContinueErrorTimeStamp(
                                                         state,
@@ -932,10 +903,10 @@ namespace HVACDXHeatPumpSystem {
                                                 } else {
                                                     ShowRecurringWarningErrorAtEnd(
                                                         state,
-                                                        DXHeatPumpSystem.DXHeatPumpSystemType + " \"" + DXHeatPumpSystem.Name +
+                                                        dxhp.DXHeatPumpSystemType + " \"" + dxhp.Name +
                                                             "\" - DX unit sensible part-load ratio calculation failed error continues. Sensible PLR "
                                                             "statistics follow.",
-                                                        DXHeatPumpSystem.DXCoilSensPLRFailIndex,
+                                                        dxhp.DXCoilSensPLRFailIndex,
                                                         PartLoadFrac,
                                                         PartLoadFrac);
                                                 }
@@ -947,8 +918,8 @@ namespace HVACDXHeatPumpSystem {
                                         PartLoadFrac = (DesOutTemp - state.dataLoopNodes->Node(InletNode).Temp) /
                                                        (TempSpeedOut - state.dataLoopNodes->Node(InletNode).Temp);
                                         SimVariableSpeedCoils(state,
-                                                              CompName,
-                                                              VSCoilIndex,
+                                                              dxhp.DXCoilName,
+                                                              dxhp.DXCoilNum,
                                                               fanOp,
                                                               HVAC::CompressorOp::On,
                                                               PartLoadFrac,
@@ -965,13 +936,13 @@ namespace HVACDXHeatPumpSystem {
                                         General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 1.0e-10, 1.0);
                                         if (SolFla == -1) {
                                             if (!state.dataGlobal->WarmupFlag) {
-                                                if (DXHeatPumpSystem.DXCoilSensPLRIter < 1) {
-                                                    ++DXHeatPumpSystem.DXCoilSensPLRIter;
+                                                if (dxhp.DXCoilSensPLRIter < 1) {
+                                                    ++dxhp.DXCoilSensPLRIter;
                                                     ShowWarningError(state,
                                                                      format("{} - Iteration limit exceeded calculating DX unit sensible part-load "
                                                                             "ratio for unit = {}",
-                                                                            DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                                            DXHeatPumpSystem.Name));
+                                                                            dxhp.DXHeatPumpSystemType,
+                                                                            dxhp.Name));
                                                     ShowContinueError(state, format("Estimated part-load ratio  = {:.3R}", (ReqOutput / FullOutput)));
                                                     ShowContinueError(state, format("Calculated part-load ratio = {:.3R}", PartLoadFrac));
                                                     ShowContinueErrorTimeStamp(
@@ -980,10 +951,10 @@ namespace HVACDXHeatPumpSystem {
                                                 } else {
                                                     ShowRecurringWarningErrorAtEnd(
                                                         state,
-                                                        DXHeatPumpSystem.DXHeatPumpSystemType + " \"" + DXHeatPumpSystem.Name +
+                                                        dxhp.DXHeatPumpSystemType + " \"" + dxhp.Name +
                                                             "\" - Iteration limit exceeded calculating sensible part-load ratio error continues. "
                                                             "Sensible PLR statistics follow.",
-                                                        DXHeatPumpSystem.DXCoilSensPLRIterIndex,
+                                                        dxhp.DXCoilSensPLRIterIndex,
                                                         PartLoadFrac,
                                                         PartLoadFrac);
                                                 }
@@ -991,13 +962,13 @@ namespace HVACDXHeatPumpSystem {
                                         } else if (SolFla == -2) {
                                             PartLoadFrac = ReqOutput / FullOutput;
                                             if (!state.dataGlobal->WarmupFlag) {
-                                                if (DXHeatPumpSystem.DXCoilSensPLRFail < 1) {
-                                                    ++DXHeatPumpSystem.DXCoilSensPLRFail;
+                                                if (dxhp.DXCoilSensPLRFail < 1) {
+                                                    ++dxhp.DXCoilSensPLRFail;
                                                     ShowWarningError(state,
                                                                      format("{} - DX unit sensible part-load ratio calculation failed: part-load "
                                                                             "ratio limits exceeded, for unit = {}",
-                                                                            DXHeatPumpSystem.DXHeatPumpSystemType,
-                                                                            DXHeatPumpSystem.Name));
+                                                                            dxhp.DXHeatPumpSystemType,
+                                                                            dxhp.Name));
                                                     ShowContinueError(state, format("Estimated part-load ratio = {:.3R}", PartLoadFrac));
                                                     ShowContinueErrorTimeStamp(
                                                         state,
@@ -1005,10 +976,10 @@ namespace HVACDXHeatPumpSystem {
                                                 } else {
                                                     ShowRecurringWarningErrorAtEnd(
                                                         state,
-                                                        DXHeatPumpSystem.DXHeatPumpSystemType + " \"" + DXHeatPumpSystem.Name +
+                                                        dxhp.DXHeatPumpSystemType + " \"" + dxhp.Name +
                                                             "\" - DX unit sensible part-load ratio calculation failed error continues. Sensible PLR "
                                                             "statistics follow.",
-                                                        DXHeatPumpSystem.DXCoilSensPLRFailIndex,
+                                                        dxhp.DXCoilSensPLRFailIndex,
                                                         PartLoadFrac,
                                                         PartLoadFrac);
                                                 }
@@ -1027,7 +998,7 @@ namespace HVACDXHeatPumpSystem {
                     } break;
                     default: {
                         ShowFatalError(state,
-                                       format("ControlDXHeatingSystem: Invalid DXHeatPumpSystem coil type = {}", DXHeatPumpSystem.HeatPumpCoilType));
+                                       format("ControlDXHeatingSystem: Invalid DXHeatPumpSystem coil type = {}", HVAC::coilTypeNames[(int)dxhp.dxCoilType]));
                     } break;
                     }
                 }
@@ -1035,9 +1006,9 @@ namespace HVACDXHeatPumpSystem {
         }     // End of If DXheatingSystem is scheduled on and there is flow
 
         // Set the final results
-        DXHeatPumpSystem.PartLoadFrac = PartLoadFrac;
-        DXHeatPumpSystem.SpeedRatio = SpeedRatio;
-        DXHeatPumpSystem.SpeedNum = SpeedNum;
+        dxhp.PartLoadFrac = PartLoadFrac;
+        dxhp.SpeedRatio = SpeedRatio;
+        dxhp.SpeedNum = SpeedNum;
     }
 
     //******************************************************************************
@@ -1125,7 +1096,7 @@ namespace HVACDXHeatPumpSystem {
         if (state.dataHVACDXHeatPumpSys->NumDXHeatPumpSystems > 0) {
             int DXHeatSysNum = Util::FindItemInList(DXHeatCoilSysName, state.dataHVACDXHeatPumpSys->DXHeatPumpSystem);
             if (DXHeatSysNum > 0 && DXHeatSysNum <= state.dataHVACDXHeatPumpSys->NumDXHeatPumpSystems) {
-                NodeNum = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilInletNodeNum;
+                NodeNum = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXHeatSysNum).DXCoilInNodeNum;
             }
         }
         if (NodeNum == 0) InletNodeErrFlag = true;
@@ -1150,7 +1121,7 @@ namespace HVACDXHeatPumpSystem {
         if (state.dataHVACDXHeatPumpSys->NumDXHeatPumpSystems > 0) {
             int DXHeatSysNum = Util::FindItemInList(DXHeatCoilSysName, state.dataHVACDXHeatPumpSys->DXHeatPumpSystem);
             if (DXHeatSysNum > 0 && DXHeatSysNum <= state.dataHVACDXHeatPumpSys->NumDXHeatPumpSystems) {
-                NodeNum = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXHeatSysNum).DXHeatPumpCoilOutletNodeNum;
+                NodeNum = state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(DXHeatSysNum).DXCoilOutNodeNum;
             }
         }
         if (NodeNum == 0) OutletNodeErrFlag = true;
@@ -1158,6 +1129,27 @@ namespace HVACDXHeatPumpSystem {
         return NodeNum;
     }
 
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilSysName)
+    {
+        if (state.dataHVACDXHeatPumpSys->GetInputFlag) { // First time subroutine has been entered
+            GetDXHeatPumpSystemInput(state);
+            state.dataHVACDXHeatPumpSys->GetInputFlag = false;
+        }
+
+        return Util::FindItemInList(coilSysName, state.dataHVACDXHeatPumpSys->DXHeatPumpSystem);
+    }
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
+    {
+      assert (coilNum > 0 && coilNum <= state.dataHVACDXHeatPumpSys->NumDXHeatPumpSystems);
+      return state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(coilNum).DXCoilInNodeNum;
+    }
+  
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert (coilNum > 0 && coilNum <= state.dataHVACDXHeatPumpSys->NumDXHeatPumpSystems);
+        return state.dataHVACDXHeatPumpSys->DXHeatPumpSystem(coilNum).DXCoilOutNodeNum;
+    }
 } // namespace HVACDXHeatPumpSystem
 
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/HVACDXHeatPumpSystem.hh b/src/EnergyPlus/HVACDXHeatPumpSystem.hh
index c8c128dadc6..838ffc5d25e 100644
--- a/src/EnergyPlus/HVACDXHeatPumpSystem.hh
+++ b/src/EnergyPlus/HVACDXHeatPumpSystem.hh
@@ -67,20 +67,24 @@ namespace HVACDXHeatPumpSystem {
     // MODULE PARAMETER DEFINITIONS
     constexpr Real64 MinAirMassFlow(0.001);
 
+    // What is the difference between this an a DXCoil?
     // Types
     struct DXHeatPumpSystemStruct
     {
         // Members
-        std::string DXHeatPumpSystemType; // Type of DXHeatingSystem
         std::string Name;                 // Name of the DXHeatingSystem
+
+        std::string DXHeatPumpSystemType; // Type of DXHeatingSystem
+      
         Sched::Schedule *availSched = nullptr;
-        std::string HeatPumpCoilType;
-        int HeatPumpCoilType_Num;
-        std::string HeatPumpCoilName;
-        int HeatPumpCoilIndex;
-        int DXHeatPumpCoilInletNodeNum;
-        int DXHeatPumpCoilOutletNodeNum;
-        int DXSystemControlNodeNum; // the node number of the node with the set point
+      
+        HVAC::CoilType dxCoilType = HVAC::CoilType::Invalid;
+        std::string DXCoilName;
+        int DXCoilNum = 0;
+        int DXCoilInNodeNum = 0;
+        int DXCoilOutNodeNum = 0;
+
+        int DXSystemControlNodeNum = 0; // the node number of the node with the set point
         Real64 DesiredOutletTemp;   // the temperature at the unit outlet node needed
         // to meet the supply air set point.
         Real64 PartLoadFrac;                      // part load fraction for current time step (single speed)
@@ -103,10 +107,9 @@ namespace HVACDXHeatPumpSystem {
 
         // Default Constructor
         DXHeatPumpSystemStruct()
-            : HeatPumpCoilType_Num(0), HeatPumpCoilIndex(0), DXHeatPumpCoilInletNodeNum(0), DXHeatPumpCoilOutletNodeNum(0), DXSystemControlNodeNum(0),
-              DesiredOutletTemp(0.0), PartLoadFrac(0.0), SpeedRatio(0.0), CycRatio(0.0), DXCoilSensPLRIter(0), DXCoilSensPLRIterIndex(0),
-              DXCoilSensPLRFail(0), DXCoilSensPLRFailIndex(0), OAUnitSetTemp(0.0), SpeedNum(0), FaultyCoilSATFlag(false), FaultyCoilSATIndex(0),
-              FaultyCoilSATOffset(0.0)
+            : DesiredOutletTemp(0.0), PartLoadFrac(0.0), SpeedRatio(0.0), CycRatio(0.0), DXCoilSensPLRIter(0),
+              DXCoilSensPLRIterIndex(0), DXCoilSensPLRFail(0), DXCoilSensPLRFailIndex(0), OAUnitSetTemp(0.0), SpeedNum(0), FaultyCoilSATFlag(false),
+              FaultyCoilSATIndex(0), FaultyCoilSATOffset(0.0)
         {
         }
     };
@@ -165,10 +168,17 @@ namespace HVACDXHeatPumpSystem {
                                int speedNumber,
                                HVAC::FanOp const fanOp);
 
-    int GetHeatingCoilInletNodeNum(EnergyPlusData &state, std::string const &DXCoilSysName, bool &InletNodeErrFlag);
+#ifdef OLD_API
+    int GetCoilAirInletNode(EnergyPlusData &state, std::string const &DXCoilSysName, bool &InletNodeErrFlag);
+
+    int GetCoilAirOutletNode(EnergyPlusData &state, std::string const &DXCoilSysName, bool &OutletNodeErrFlag);
+#endif // OLD_API
+
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
 
-    int GetHeatingCoilOutletNodeNum(EnergyPlusData &state, std::string const &DXCoilSysName, bool &OutletNodeErrFlag);
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
 
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
 } // namespace HVACDXHeatPumpSystem
 
 struct HVACDXHeatPumpSystemData : BaseGlobalStruct
@@ -183,7 +193,6 @@ struct HVACDXHeatPumpSystemData : BaseGlobalStruct
     Real64 QZnReq = 0.001;          // Zone load (W), input to variable-speed DX coil
     Real64 QLatReq = 0.0;           // Zone latent load, input to variable-speed DX coil
     Real64 OnOffAirFlowRatio = 1.0; // ratio of compressor on flow to average flow over time step
-    bool ErrorsFound = false;       // If errors detected in input
     int TotalArgs = 0;              // Total number of alpha and numeric arguments (max) for a certain object in the input file
     bool MySetPointCheckFlag = true;
     int SpeedNum = 1;                  // speed number of variable speed DX cooling coil
@@ -215,7 +224,6 @@ struct HVACDXHeatPumpSystemData : BaseGlobalStruct
         this->QZnReq = 0.001;
         this->QLatReq = 0.0;
         this->OnOffAirFlowRatio = 1.0;
-        this->ErrorsFound = false;
         this->TotalArgs = 0;
         this->MySetPointCheckFlag = true;
         this->SpeedNum = 1;
diff --git a/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc b/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc
index 996d13543de..49655d0075c 100644
--- a/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc
+++ b/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc
@@ -71,7 +71,7 @@
 
 namespace EnergyPlus {
 
-namespace HVACHXAssistedCoolingCoil {
+namespace HXAssistCoil {
     // Module containing the simulation routines for a heat exchanger-
     // assisted cooling coil
 
@@ -132,7 +132,7 @@ namespace HVACHXAssistedCoolingCoil {
 
         // Find the correct HXAssistedCoolingCoil number
         if (CompIndex == 0) {
-            HXAssistedCoilNum = Util::FindItemInList(HXAssistedCoilName, state.dataHVACAssistedCC->HXAssistedCoil);
+            HXAssistedCoilNum = Util::FindItemInList(HXAssistedCoilName, state.dataHVACAssistedCC->HXAssistedCoils);
             if (HXAssistedCoilNum == 0) {
                 ShowFatalError(state, format("HX Assisted Coil not found={}", HXAssistedCoilName));
             }
@@ -147,19 +147,51 @@ namespace HVACHXAssistedCoolingCoil {
                                       HXAssistedCoilName));
             }
             if (state.dataHVACAssistedCC->CheckEquipName(HXAssistedCoilNum)) {
-                if (!HXAssistedCoilName.empty() && HXAssistedCoilName != state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).Name) {
+                if (!HXAssistedCoilName.empty() && HXAssistedCoilName != state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum).Name) {
                     ShowFatalError(state,
                                    format("SimHXAssistedCoolingCoil: Invalid CompIndex passed={}, Coil name={}, stored Coil Name for that index={}",
                                           HXAssistedCoilNum,
                                           HXAssistedCoilName,
-                                          state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).Name));
+                                          state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum).Name));
                 }
                 state.dataHVACAssistedCC->CheckEquipName(HXAssistedCoilNum) = false;
             }
         }
+        
+        SimHXAssistedCoolingCoil(state,
+                                 HXAssistedCoilNum, 
+                                 FirstHVACIteration,
+                                 compressorOp,
+                                 PartLoadRatio,
+                                 fanOp,
+                                 HXUnitEnable,
+                                 OnOffAFR,
+                                 EconomizerFlag,
+                                 QTotOut,
+                                 DehumidificationMode,
+                                 LoadSHR);
+    }
+
+    void SimHXAssistedCoolingCoil(EnergyPlusData &state,
+                                  int const coilNum, 
+                                  bool const FirstHVACIteration,         // FirstHVACIteration flag
+                                  HVAC::CompressorOp const compressorOp, // compressor operation; 1=on, 0=off
+                                  Real64 const PartLoadRatio,            // Part load ratio of Coil:DX:CoolingBypassFactorEmpirical
+                                  HVAC::FanOp const fanOp,                     // Allows the parent object to control fan operation
+                                  ObjexxFCL::Optional_bool_const HXUnitEnable, // flag to enable heat exchanger heat recovery
+                                  ObjexxFCL::Optional<Real64 const> OnOffAFR,  // Ratio of compressor ON air mass flow rate to AVERAGE over time step
+                                  ObjexxFCL::Optional_bool_const EconomizerFlag,                  // OA sys or air loop economizer status
+                                  ObjexxFCL::Optional<Real64> QTotOut,                            // the total cooling output of unit
+                                  ObjexxFCL::Optional<HVAC::CoilMode const> DehumidificationMode, // Optional dehumbidication mode
+                                  ObjexxFCL::Optional<Real64 const> LoadSHR                       // Optional CoilSHR pass over
+    )
+    {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        Real64 AirFlowRatio;   // Ratio of compressor ON air mass flow rate to AVEARAGE over time step
+        bool HXUnitOn;         // flag to enable heat exchanger
 
         // Initialize HXAssistedCoolingCoil Flows
-        InitHXAssistedCoolingCoil(state, HXAssistedCoilNum);
+        InitHXAssistedCoolingCoil(state, coilNum);
 
         if (present(HXUnitEnable)) {
             HXUnitOn = HXUnitEnable;
@@ -177,10 +209,11 @@ namespace HVACHXAssistedCoolingCoil {
         } else {
             AirFlowRatio = 1.0;
         }
+        
         if (present(DehumidificationMode) && present(LoadSHR) &&
-            state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+            state.dataHVACAssistedCC->HXAssistedCoils(coilNum).coolCoilType == HVAC::CoilType::CoolingDX) {
             CalcHXAssistedCoolingCoil(state,
-                                      HXAssistedCoilNum,
+                                      coilNum,
                                       FirstHVACIteration,
                                       compressorOp,
                                       PartLoadRatio,
@@ -192,7 +225,7 @@ namespace HVACHXAssistedCoolingCoil {
                                       LoadSHR);
         } else {
             CalcHXAssistedCoolingCoil(
-                state, HXAssistedCoilNum, FirstHVACIteration, compressorOp, PartLoadRatio, HXUnitOn, fanOp, AirFlowRatio, EconomizerFlag);
+                state, coilNum, FirstHVACIteration, compressorOp, PartLoadRatio, HXUnitOn, fanOp, AirFlowRatio, EconomizerFlag);
         }
 
         // Update the current HXAssistedCoil output
@@ -202,13 +235,13 @@ namespace HVACHXAssistedCoolingCoil {
         //  Call ReportHXAssistedCoolingCoil(HXAssistedCoilNum), not required. No reporting variables for this compound component.
 
         if (present(QTotOut)) {
-            int InletNodeNum = state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).HXAssistedCoilInletNodeNum;
-            int OutletNodeNum = state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).HXAssistedCoilOutletNodeNum;
+            int InletNodeNum = state.dataHVACAssistedCC->HXAssistedCoils(coilNum).HXCoilInNodeNum;
+            int OutletNodeNum = state.dataHVACAssistedCC->HXAssistedCoils(coilNum).HXCoilOutNodeNum;
             Real64 AirMassFlow = state.dataLoopNodes->Node(OutletNodeNum).MassFlowRate;
             QTotOut = AirMassFlow * (state.dataLoopNodes->Node(InletNodeNum).Enthalpy - state.dataLoopNodes->Node(OutletNodeNum).Enthalpy);
         }
     }
-
+  
     // Get Input Section of the Module
     //******************************************************************************
 
@@ -229,21 +262,15 @@ namespace HVACHXAssistedCoolingCoil {
         static constexpr std::string_view RoutineName("GetHXAssistedCoolingCoilInput: "); // include trailing blank space
         static constexpr std::string_view routineName = "GetHXAssistedCoolingCoilInput";
 
+        auto &s_node = state.dataLoopNodes;
+
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        int HXAssistedCoilNum;            // Index number of the HXAssistedCoolingCoil for which input data is being read from the idf
         int NumAlphas;                    // Number of alpha inputs
         int NumNums;                      // Number of number inputs
         int IOStat;                       // Return status from GetObjectItem call
         bool ErrorsFound(false);          // set TRUE if errors detected in input
         bool HXErrFlag;                   // Error flag for HX node numbers mining call
         bool CoolingCoilErrFlag;          // Error flag for cooling coil node numbers mining call
-        int SupplyAirInletNode;           // supply air inlet node number mined from heat exchanger object (ExchCond structure)
-        int SupplyAirOutletNode;          // supply air outlet node number mined from heat exchanger object (ExchCond structure)
-        int SecondaryAirInletNode;        // secondary air inlet node number mined from heat exchanger object (ExchCond structure)
-        int SecondaryAirOutletNode;       // secondary air outlet node number mined from heat exchanger object (ExchCond structure)
-        int CoolingCoilInletNodeNum;      // air outlet node number of cooling coil, used for warning messages
-        int CoolingCoilWaterInletNodeNum; // water coil water inlet node number used to find controller index
-        int CoolingCoilOutletNodeNum;     // air outlet node number of cooling coil, used for warning messages
         std::string CurrentModuleObject;  // Object type for getting and error messages
         Array1D_string AlphArray;         // Alpha input items for object
         Array1D_string cAlphaFields;      // Alpha field names
@@ -259,7 +286,7 @@ namespace HVACHXAssistedCoolingCoil {
             state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "CoilSystem:Cooling:Water:HeatExchangerAssisted");
         state.dataHVACAssistedCC->TotalNumHXAssistedCoils = NumHXAssistedDXCoils + NumHXAssistedWaterCoils;
         if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            state.dataHVACAssistedCC->HXAssistedCoil.allocate(state.dataHVACAssistedCC->TotalNumHXAssistedCoils);
+            state.dataHVACAssistedCC->HXAssistedCoils.allocate(state.dataHVACAssistedCC->TotalNumHXAssistedCoils);
             state.dataHVACAssistedCC->HXAssistedCoilOutletTemp.allocate(state.dataHVACAssistedCC->TotalNumHXAssistedCoils);
             state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat.allocate(state.dataHVACAssistedCC->TotalNumHXAssistedCoils);
             state.dataHVACAssistedCC->CheckEquipName.dimension(state.dataHVACAssistedCC->TotalNumHXAssistedCoils, true);
@@ -285,8 +312,8 @@ namespace HVACHXAssistedCoolingCoil {
         // Get the data for the Coil:DX:CoolingHeatExchangerAssisted objects
         CurrentModuleObject = "CoilSystem:Cooling:DX:HeatExchangerAssisted";
 
-        for (HXAssistedCoilNum = 1; HXAssistedCoilNum <= NumHXAssistedDXCoils; ++HXAssistedCoilNum) {
-            auto &thisHXCoil = state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum);
+        for (int HXAssistedCoilNum = 1; HXAssistedCoilNum <= NumHXAssistedDXCoils; ++HXAssistedCoilNum) {
+            auto &hxCoil = state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum);
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      CurrentModuleObject,
                                                                      HXAssistedCoilNum,
@@ -299,270 +326,238 @@ namespace HVACHXAssistedCoolingCoil {
                                                                      lAlphaBlanks,
                                                                      cAlphaFields,
                                                                      cNumericFields);
+
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, AlphArray(1)};
+            
             GlobalNames::VerifyUniqueInterObjectName(
                 state, state.dataHVACAssistedCC->UniqueHXAssistedCoilNames, AlphArray(1), CurrentModuleObject, ErrorsFound);
 
-            thisHXCoil.Name = AlphArray(1);
-            thisHXCoil.hxType = static_cast<HVAC::HXType>(getEnumValue(HVAC::hxTypeNamesUC, AlphArray(2)));
-            thisHXCoil.HeatExchangerName = AlphArray(3);
-
-            thisHXCoil.CoolingCoilType = AlphArray(4);
-            thisHXCoil.CoolingCoilName = AlphArray(5);
-
-            if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:DX")) {
-                thisHXCoil.CoolingCoilType_Num = HVAC::CoilDX_Cooling;
-                thisHXCoil.HXAssistedCoilType = CurrentModuleObject;
-                thisHXCoil.HXAssistedCoilType_Num = HVAC::CoilDX_CoolingHXAssisted;
-
-                CoolingCoilErrFlag = false;
-                int coolingCoilIndex_temp = CoilCoolingDX::factory(state, thisHXCoil.CoolingCoilName);
-                thisHXCoil.CoolingCoilIndex = coolingCoilIndex_temp;
-                if (coolingCoilIndex_temp < 0) {
-                    ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, AlphArray(5)));
-                    CoolingCoilErrFlag = true;
-                    ErrorsFound = true;
-                }
-
-                thisHXCoil.DXCoilNumOfSpeeds = state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex_temp].performance.normalMode.speeds.size();
-                if (thisHXCoil.DXCoilNumOfSpeeds < 1) {
-                    CoolingCoilErrFlag = true;
-                }
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-                    ErrorsFound = true;
-                }
-            } else if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:DX:SingleSpeed")) {
-                thisHXCoil.CoolingCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
-                thisHXCoil.HXAssistedCoilType = CurrentModuleObject;
-                thisHXCoil.HXAssistedCoilType_Num = HVAC::CoilDX_CoolingHXAssisted;
-                CoolingCoilErrFlag = false;
-                DXCoils::GetDXCoilIndex(
-                    state, thisHXCoil.CoolingCoilName, thisHXCoil.CoolingCoilIndex, CoolingCoilErrFlag, thisHXCoil.CoolingCoilType);
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
+            hxCoil.Name = AlphArray(1);
+            hxCoil.hxType = static_cast<HVAC::HXType>(getEnumValue(HVAC::hxTypeNamesUC, AlphArray(2)));
+            hxCoil.HeatExchangerName = AlphArray(3);
+            hxCoil.HeatExchangerNum = HeatRecovery::GetHeatExchangerIndex(state, hxCoil.HeatExchangerName);
+            if (hxCoil.HeatExchangerNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(3), hxCoil.HeatExchangerName);
+                ErrorsFound = true;
+            } else {
+                hxCoil.MaxAirFlowRate = HeatRecovery::GetSupplyAirFlowRate(state, hxCoil.HeatExchangerNum);
+                hxCoil.SupplyAirInNodeNum = HeatRecovery::GetSupplyInletNode(state, hxCoil.HeatExchangerNum);
+                hxCoil.SupplyAirOutNodeNum = HeatRecovery::GetSupplyOutletNode(state, hxCoil.HeatExchangerNum);
+                hxCoil.SecAirInNodeNum = HeatRecovery::GetSecondaryInletNode(state, hxCoil.HeatExchangerNum);
+                hxCoil.SecAirOutNodeNum = HeatRecovery::GetSecondaryOutletNode(state, hxCoil.HeatExchangerNum);
+            }
+            
+            hxCoil.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, AlphArray(4)));
+            hxCoil.CoolCoilName = AlphArray(5);
+
+            if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDX) {
+                hxCoil.coilType = HVAC::CoilType::CoolingDXHXAssisted;
+                // What is this factory thing, seriously?
+                hxCoil.CoolCoilNum = CoilCoolingDX::factory(state, hxCoil.CoolCoilName); 
+                if (hxCoil.CoolCoilNum < 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(5), hxCoil.CoolCoilName);
                     ErrorsFound = true;
+                } else {
+                    auto &coilDX = state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum];
+                    hxCoil.Capacity = coilDX.performance.normalMode.ratedGrossTotalCap;
+                    hxCoil.DXCoilNumOfSpeeds = coilDX.performance.normalMode.speeds.size();
                 }
-            } else if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:DX:VariableSpeed")) {
-                thisHXCoil.CoolingCoilType_Num = HVAC::Coil_CoolingAirToAirVariableSpeed;
-                thisHXCoil.HXAssistedCoilType = CurrentModuleObject;
-                thisHXCoil.HXAssistedCoilType_Num = HVAC::CoilDX_CoolingHXAssisted;
-                CoolingCoilErrFlag = false;
-                thisHXCoil.CoolingCoilIndex = VariableSpeedCoils::GetCoilIndexVariableSpeed(state, AlphArray(4), AlphArray(5), CoolingCoilErrFlag);
-
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
+                
+            } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+                hxCoil.coilType = HVAC::CoilType::CoolingDXHXAssisted;
+                hxCoil.CoolCoilNum = DXCoils::GetCoilIndex(state, hxCoil.CoolCoilName);
+                if (hxCoil.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(5), hxCoil.CoolCoilName);
                     ErrorsFound = true;
+                } else {
+                    hxCoil.DXCoilNumOfSpeeds = DXCoils::GetCoilNumberOfSpeeds(state, hxCoil.CoolCoilNum);
+                    hxCoil.Capacity = DXCoils::GetCoilCapacity(state, hxCoil.CoolCoilNum);
                 }
-                thisHXCoil.DXCoilNumOfSpeeds = VariableSpeedCoils::GetVSCoilNumOfSpeeds(state, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
+                
+            } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                hxCoil.coilType = HVAC::CoilType::CoolingDXHXAssisted;
+                hxCoil.CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, AlphArray(5));
+                if (hxCoil.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(5), AlphArray(5));
                     ErrorsFound = true;
+                } else {
+                    hxCoil.Capacity = VariableSpeedCoils::GetCoilCapacity(state, hxCoil.CoolCoilNum);
+                    hxCoil.DXCoilNumOfSpeeds = VariableSpeedCoils::GetCoilNumOfSpeeds(state, hxCoil.CoolCoilNum);
                 }
             } else {
-                ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
-                ShowContinueError(state, format("Invalid {}=\"{}\"", cAlphaFields(4), thisHXCoil.CoolingCoilType));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(4), AlphArray(4));
                 ErrorsFound = true;
             }
 
-            HXErrFlag = false;
-            SupplyAirInletNode = HeatRecovery::GetSupplyInletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-            }
-
-            HXErrFlag = false;
-            SupplyAirOutletNode = HeatRecovery::GetSupplyOutletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-            }
-
-            HXErrFlag = false;
-            SecondaryAirInletNode = HeatRecovery::GetSecondaryInletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-            }
-
-            HXErrFlag = false;
-            SecondaryAirOutletNode = HeatRecovery::GetSecondaryOutletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-            }
-
-            if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:DX")) {
-                CoolingCoilInletNodeNum = state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].evapInletNodeIndex;
-                if (SupplyAirOutletNode != CoolingCoilInletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
+            if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDX) {
+                hxCoil.CoolCoilInNodeNum = state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum].evapInletNodeIndex;
+                if (hxCoil.SupplyAirOutNodeNum != hxCoil.CoolCoilInNodeNum) {
+                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
                     ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
                     ShowContinueError(state,
                                       format("The supply air outlet node name in heat exchanger {}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
+                                             HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                             hxCoil.HeatExchangerName));
                     ShowContinueError(
                         state,
-                        format("must match the cooling coil inlet node name in {}=\"{}\"", thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName));
+                        format("must match the cooling coil inlet node name in {}=\"{}\"", HVAC::coilTypeNames[(int)hxCoil.coolCoilType], hxCoil.CoolCoilName));
                     ShowContinueError(state,
-                                      format("Heat exchanger supply air outlet node name=\"{}\"", state.dataLoopNodes->NodeID(SupplyAirOutletNode)));
-                    ShowContinueError(state, format("Cooling coil air inlet node name=\"{}\"", state.dataLoopNodes->NodeID(CoolingCoilInletNodeNum)));
+                                      format("Heat exchanger supply air outlet node name=\"{}\"", s_node->NodeID(hxCoil.SupplyAirOutNodeNum)));
+                    ShowContinueError(state, format("Cooling coil air inlet node name=\"{}\"", s_node->NodeID(hxCoil.CoolCoilInNodeNum)));
                     ErrorsFound = true;
                 }
 
-                CoolingCoilOutletNodeNum = state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].evapOutletNodeIndex;
-                if (SecondaryAirInletNode != CoolingCoilOutletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
+                hxCoil.CoolCoilOutNodeNum = state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum].evapOutletNodeIndex;
+                if (hxCoil.SecAirInNodeNum != hxCoil.CoolCoilOutNodeNum) {
+                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
                     ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
                     ShowContinueError(state,
                                       format("The secondary air inlet node name in heat exchanger {}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
+                                             HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                             hxCoil.HeatExchangerName));
                     ShowContinueError(state,
                                       format("must match the cooling coil air outlet node name in {}=\"{}\"",
-                                             thisHXCoil.CoolingCoilType,
-                                             thisHXCoil.CoolingCoilName));
+                                             HVAC::coilTypeNames[(int)hxCoil.coolCoilType],
+                                             hxCoil.CoolCoilName));
                     ShowContinueError(
-                        state, format("Heat exchanger secondary air inlet node name =\"{}\".", state.dataLoopNodes->NodeID(SecondaryAirInletNode)));
+                        state, format("Heat exchanger secondary air inlet node name =\"{}\".", s_node->NodeID(hxCoil.SecAirInNodeNum)));
                     ShowContinueError(state,
-                                      format("Cooling coil air outlet node name =\"{}\".", state.dataLoopNodes->NodeID(CoolingCoilOutletNodeNum)));
+                                      format("Cooling coil air outlet node name =\"{}\".", s_node->NodeID(hxCoil.CoolCoilOutNodeNum)));
                     ErrorsFound = true;
                 }
+                hxCoil.CoolCoilCondenserInNodeNum = state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum].condInletNodeIndex;
 
-            } else if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:DX:SingleSpeed")) {
+            } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                 //         Check node names in heat exchanger and coil objects for consistency
-                CoolingCoilErrFlag = false;
-                CoolingCoilInletNodeNum =
-                    DXCoils::GetCoilInletNode(state, thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-                }
-                if (SupplyAirOutletNode != CoolingCoilInletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
+                hxCoil.CoolCoilInNodeNum = DXCoils::GetCoilAirInletNode(state, hxCoil.CoolCoilNum);
+                if (hxCoil.SupplyAirOutNodeNum != hxCoil.CoolCoilInNodeNum) {
+                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
                     ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
                     ShowContinueError(state,
                                       format("The supply air outlet node name in heat exchanger = {}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
+                                             HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                             hxCoil.HeatExchangerName));
                     ShowContinueError(
                         state,
-                        format("must match the cooling coil inlet node name in = {}=\"{}\"", thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName));
+                        format("must match the cooling coil inlet node name in = {}=\"{}\"", HVAC::coilTypeNames[(int)hxCoil.coolCoilType], hxCoil.CoolCoilName));
                     ShowContinueError(state,
-                                      format("Heat exchanger supply air outlet node name=\"{}\"", state.dataLoopNodes->NodeID(SupplyAirOutletNode)));
-                    ShowContinueError(state, format("Cooling coil air inlet node name=\"{}\"", state.dataLoopNodes->NodeID(CoolingCoilInletNodeNum)));
+                                      format("Heat exchanger supply air outlet node name=\"{}\"", s_node->NodeID(hxCoil.SupplyAirOutNodeNum)));
+                    ShowContinueError(state, format("Cooling coil air inlet node name=\"{}\"", s_node->NodeID(hxCoil.CoolCoilInNodeNum)));
                     ErrorsFound = true;
                 }
-                CoolingCoilErrFlag = false;
-                CoolingCoilOutletNodeNum =
-                    DXCoils::GetCoilOutletNode(state, thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-                }
-                if (SecondaryAirInletNode != CoolingCoilOutletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
+
+                hxCoil.CoolCoilOutNodeNum = DXCoils::GetCoilAirOutletNode(state, hxCoil.CoolCoilNum);
+                if (hxCoil.SecAirInNodeNum != hxCoil.CoolCoilOutNodeNum) {
+                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
                     ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
                     ShowContinueError(state,
                                       format("The secondary air inlet node name in heat exchanger ={}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
+                                             HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                             hxCoil.HeatExchangerName));
                     ShowContinueError(state,
                                       format("must match the cooling coil air outlet node name in = {}=\"{}\".",
-                                             thisHXCoil.CoolingCoilType,
-                                             thisHXCoil.CoolingCoilName));
+                                             HVAC::coilTypeNames[(int)hxCoil.coolCoilType],
+                                             hxCoil.CoolCoilName));
                     ShowContinueError(
-                        state, format("Heat exchanger secondary air inlet node name =\"{}\".", state.dataLoopNodes->NodeID(SecondaryAirInletNode)));
+                        state, format("Heat exchanger secondary air inlet node name =\"{}\".", s_node->NodeID(hxCoil.SecAirInNodeNum)));
                     ShowContinueError(state,
-                                      format("Cooling coil air outlet node name =\"{}\".", state.dataLoopNodes->NodeID(CoolingCoilOutletNodeNum)));
+                                      format("Cooling coil air outlet node name =\"{}\".", s_node->NodeID(hxCoil.CoolCoilOutNodeNum)));
                     ErrorsFound = true;
                 }
 
-            } else if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:DX:VariableSpeed")) {
+                hxCoil.CoolCoilCondenserInNodeNum = DXCoils::GetCoilCondenserInletNode(state, hxCoil.CoolCoilNum);
+
+            } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                 //         Check node names in heat exchanger and coil objects for consistency
-                CoolingCoilErrFlag = false;
-                CoolingCoilInletNodeNum = VariableSpeedCoils::GetCoilInletNodeVariableSpeed(
-                    state, thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-                }
-                if (SupplyAirOutletNode != CoolingCoilInletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
+                hxCoil.CoolCoilInNodeNum = VariableSpeedCoils::GetCoilAirInletNode(state, hxCoil.CoolCoilNum);
+                if (hxCoil.SupplyAirOutNodeNum != hxCoil.CoolCoilInNodeNum) {
+                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
                     ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
                     ShowContinueError(state,
                                       format("The supply air outlet node name in heat exchanger = {}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
+                                             HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                             hxCoil.HeatExchangerName));
                     ShowContinueError(
                         state,
-                        format("must match the cooling coil inlet node name in = {}=\"{}\"", thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName));
+                        format("must match the cooling coil inlet node name in = {}=\"{}\"", HVAC::coilTypeNames[(int)hxCoil.coolCoilType], hxCoil.CoolCoilName));
                     ShowContinueError(state,
-                                      format("Heat exchanger supply air outlet node name=\"{}\"", state.dataLoopNodes->NodeID(SupplyAirOutletNode)));
-                    ShowContinueError(state, format("Cooling coil air inlet node name=\"{}\"", state.dataLoopNodes->NodeID(CoolingCoilInletNodeNum)));
+                                      format("Heat exchanger supply air outlet node name=\"{}\"", s_node->NodeID(hxCoil.SupplyAirOutNodeNum)));
+                    ShowContinueError(state, format("Cooling coil air inlet node name=\"{}\"", s_node->NodeID(hxCoil.CoolCoilInNodeNum)));
                     ErrorsFound = true;
                 }
-                CoolingCoilErrFlag = false;
-                CoolingCoilOutletNodeNum = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(
-                    state, thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                if (CoolingCoilErrFlag) {
-                    ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
+
+                hxCoil.CoolCoilOutNodeNum = VariableSpeedCoils::GetCoilAirOutletNode(state, hxCoil.CoolCoilNum);
+                if (hxCoil.CoolCoilOutNodeNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(5), AlphArray(5));
+                    ErrorsFound = true;
                 }
-                if (SecondaryAirInletNode != CoolingCoilOutletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
+                if (hxCoil.SecAirInNodeNum != hxCoil.CoolCoilOutNodeNum) {
+                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
                     ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
                     ShowContinueError(state,
                                       format("The secondary air inlet node name in heat exchanger ={}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
+                                             HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                             hxCoil.HeatExchangerName));
                     ShowContinueError(state,
                                       format("must match the cooling coil air outlet node name in = {}=\"{}\".",
-                                             thisHXCoil.CoolingCoilType,
-                                             thisHXCoil.CoolingCoilName));
+                                             HVAC::coilTypeNames[(int)hxCoil.coolCoilType],
+                                             hxCoil.CoolCoilName));
                     ShowContinueError(
-                        state, format("Heat exchanger secondary air inlet node name =\"{}\".", state.dataLoopNodes->NodeID(SecondaryAirInletNode)));
+                        state, format("Heat exchanger secondary air inlet node name =\"{}\".", s_node->NodeID(hxCoil.SecAirInNodeNum)));
                     ShowContinueError(state,
-                                      format("Cooling coil air outlet node name =\"{}\".", state.dataLoopNodes->NodeID(CoolingCoilOutletNodeNum)));
+                                      format("Cooling coil air outlet node name =\"{}\".", s_node->NodeID(hxCoil.CoolCoilOutNodeNum)));
                     ErrorsFound = true;
                 }
+                
+                hxCoil.CoolCoilCondenserInNodeNum = VariableSpeedCoils::GetCoilCondenserInletNode(state, hxCoil.CoolCoilNum);
             }
 
             BranchNodeConnections::TestCompSet(state,
-                                               thisHXCoil.HXAssistedCoilType,
-                                               thisHXCoil.Name,
-                                               state.dataLoopNodes->NodeID(SupplyAirInletNode),
-                                               state.dataLoopNodes->NodeID(SecondaryAirOutletNode),
+                                               HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                               hxCoil.Name,
+                                               s_node->NodeID(hxCoil.SupplyAirInNodeNum),
+                                               s_node->NodeID(hxCoil.SecAirOutNodeNum),
                                                "Air Nodes");
 
-            thisHXCoil.HXAssistedCoilInletNodeNum =
+            hxCoil.HXCoilInNodeNum =
                 NodeInputManager::GetOnlySingleNode(state,
-                                                    state.dataLoopNodes->NodeID(SupplyAirInletNode),
+                                                    s_node->NodeID(hxCoil.SupplyAirInNodeNum),
                                                     ErrorsFound,
                                                     DataLoopNode::ConnectionObjectType::CoilSystemCoolingDXHeatExchangerAssisted,
-                                                    thisHXCoil.Name,
+                                                    hxCoil.Name,
                                                     DataLoopNode::NodeFluidType::Air,
                                                     DataLoopNode::ConnectionType::Inlet,
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
             // no need to capture CoolingCoilInletNodeNum as the return value, it's not used anywhere
-            NodeInputManager::GetOnlySingleNode(state,
-                                                state.dataLoopNodes->NodeID(SupplyAirOutletNode),
+            // Actually, it's a good idea to capture it anyway
+            hxCoil.CoolCoilInNodeNum =
+                NodeInputManager::GetOnlySingleNode(state,
+                                                s_node->NodeID(hxCoil.SupplyAirOutNodeNum),
                                                 ErrorsFound,
                                                 DataLoopNode::ConnectionObjectType::CoilSystemCoolingDXHeatExchangerAssisted,
-                                                state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).Name,
+                                                hxCoil.Name,
                                                 DataLoopNode::NodeFluidType::Air,
                                                 DataLoopNode::ConnectionType::Internal,
                                                 NodeInputManager::CompFluidStream::Primary,
                                                 DataLoopNode::ObjectIsParent);
-            thisHXCoil.HXExhaustAirInletNodeNum =
+
+            hxCoil.HXCoilExhaustAirInNodeNum =
                 NodeInputManager::GetOnlySingleNode(state,
-                                                    state.dataLoopNodes->NodeID(SecondaryAirInletNode),
+                                                    s_node->NodeID(hxCoil.SecAirInNodeNum),
                                                     ErrorsFound,
                                                     DataLoopNode::ConnectionObjectType::CoilSystemCoolingDXHeatExchangerAssisted,
-                                                    thisHXCoil.Name,
+                                                    hxCoil.Name,
                                                     DataLoopNode::NodeFluidType::Air,
                                                     DataLoopNode::ConnectionType::Internal,
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
-            thisHXCoil.HXAssistedCoilOutletNodeNum =
+            hxCoil.HXCoilOutNodeNum =
                 NodeInputManager::GetOnlySingleNode(state,
-                                                    state.dataLoopNodes->NodeID(SecondaryAirOutletNode),
+                                                    s_node->NodeID(hxCoil.SecAirOutNodeNum),
                                                     ErrorsFound,
                                                     DataLoopNode::ConnectionObjectType::CoilSystemCoolingDXHeatExchangerAssisted,
-                                                    thisHXCoil.Name,
+                                                    hxCoil.Name,
                                                     DataLoopNode::NodeFluidType::Air,
                                                     DataLoopNode::ConnectionType::Outlet,
                                                     NodeInputManager::CompFluidStream::Primary,
@@ -570,29 +565,29 @@ namespace HVACHXAssistedCoolingCoil {
 
             // Add cooling coil to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisHXCoil.HXAssistedCoilType,
-                                                 thisHXCoil.Name,
-                                                 thisHXCoil.CoolingCoilType,
-                                                 thisHXCoil.CoolingCoilName,
-                                                 state.dataLoopNodes->NodeID(SupplyAirOutletNode),
-                                                 state.dataLoopNodes->NodeID(SecondaryAirInletNode),
+                                                 HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                                 hxCoil.Name,
+                                                 HVAC::coilTypeNames[(int)hxCoil.coolCoilType],
+                                                 hxCoil.CoolCoilName,
+                                                 s_node->NodeID(hxCoil.SupplyAirOutNodeNum),
+                                                 s_node->NodeID(hxCoil.SecAirInNodeNum),
                                                  "Air Nodes");
             // Add heat exchanger to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisHXCoil.HXAssistedCoilType,
-                                                 thisHXCoil.Name,
-                                                 HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                                 thisHXCoil.HeatExchangerName,
-                                                 state.dataLoopNodes->NodeID(SupplyAirInletNode),
-                                                 state.dataLoopNodes->NodeID(SupplyAirOutletNode),
+                                                 HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                                 hxCoil.Name,
+                                                 HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                                 hxCoil.HeatExchangerName,
+                                                 s_node->NodeID(hxCoil.SupplyAirInNodeNum),
+                                                 s_node->NodeID(hxCoil.SupplyAirOutNodeNum),
                                                  "Process Air Nodes");
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisHXCoil.HXAssistedCoilType,
-                                                 thisHXCoil.Name,
-                                                 HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                                 thisHXCoil.HeatExchangerName,
-                                                 state.dataLoopNodes->NodeID(SecondaryAirInletNode),
-                                                 state.dataLoopNodes->NodeID(SecondaryAirOutletNode),
+                                                 HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                                 hxCoil.Name,
+                                                 HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                                 hxCoil.HeatExchangerName,
+                                                 s_node->NodeID(hxCoil.SecAirInNodeNum),
+                                                 s_node->NodeID(hxCoil.SecAirOutNodeNum),
                                                  "Secondary Air Nodes");
 
         } // End of the Coil:DX:CoolingHXAssisted Loop
@@ -600,10 +595,10 @@ namespace HVACHXAssistedCoolingCoil {
         // Get the data for the Coil:Water:CoolingHeatExchangerAssisted objects
         CurrentModuleObject = "CoilSystem:Cooling:Water:HeatExchangerAssisted";
 
-        for (HXAssistedCoilNum = NumHXAssistedDXCoils + 1; HXAssistedCoilNum <= state.dataHVACAssistedCC->TotalNumHXAssistedCoils;
+        for (int HXAssistedCoilNum = NumHXAssistedDXCoils + 1; HXAssistedCoilNum <= state.dataHVACAssistedCC->TotalNumHXAssistedCoils;
              ++HXAssistedCoilNum) {
             int thisWaterHXNum = HXAssistedCoilNum - NumHXAssistedDXCoils;
-            auto &thisHXCoil = state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum);
+            auto &hxCoil = state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum);
 
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      CurrentModuleObject,
@@ -623,147 +618,136 @@ namespace HVACHXAssistedCoolingCoil {
             GlobalNames::VerifyUniqueInterObjectName(
                 state, state.dataHVACAssistedCC->UniqueHXAssistedCoilNames, AlphArray(1), CurrentModuleObject, ErrorsFound);
 
-            thisHXCoil.Name = AlphArray(1);
+            hxCoil.Name = AlphArray(1);
 
-            thisHXCoil.hxType = static_cast<HVAC::HXType>(getEnumValue(HVAC::hxTypeNamesUC, AlphArray(2)));
-            if (thisHXCoil.hxType == HVAC::HXType::Desiccant_Balanced) {
+            hxCoil.hxType = static_cast<HVAC::HXType>(getEnumValue(HVAC::hxTypeNamesUC, AlphArray(2)));
+            if (hxCoil.hxType == HVAC::HXType::Desiccant_Balanced) {
                 ShowSevereInvalidKey(state, eoh, cAlphaFields(2), AlphArray(2));
                 ErrorsFound = true;
             }
-            thisHXCoil.HeatExchangerName = AlphArray(3);
-            thisHXCoil.CoolingCoilType = AlphArray(4);
-            thisHXCoil.CoolingCoilName = AlphArray(5);
-
-            HXErrFlag = false;
-            SupplyAirInletNode = HeatRecovery::GetSupplyInletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-            }
-
-            HXErrFlag = false;
-            SupplyAirOutletNode = HeatRecovery::GetSupplyOutletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}", CurrentModuleObject, thisHXCoil.Name));
-            }
-
-            HXErrFlag = false;
-            SecondaryAirInletNode = HeatRecovery::GetSecondaryInletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
-            }
-
-            HXErrFlag = false;
-            SecondaryAirOutletNode = HeatRecovery::GetSecondaryOutletNode(state, thisHXCoil.HeatExchangerName, HXErrFlag);
-            if (HXErrFlag) {
-                ShowContinueError(state, format("...Occurs in {}=\"{}\"", CurrentModuleObject, thisHXCoil.Name));
+            
+            hxCoil.HeatExchangerName = AlphArray(3);
+            hxCoil.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, AlphArray(4)));
+            hxCoil.CoolCoilName = AlphArray(5);
+
+            hxCoil.HeatExchangerNum = HeatRecovery::GetHeatExchangerIndex(state, hxCoil.HeatExchangerName);
+            if (hxCoil.HeatExchangerNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(5), hxCoil.HeatExchangerName);
+                ErrorsFound = true;
+            } else {
+                hxCoil.SupplyAirInNodeNum = HeatRecovery::GetSupplyInletNode(state, hxCoil.HeatExchangerNum);
+                hxCoil.SupplyAirOutNodeNum = HeatRecovery::GetSupplyOutletNode(state, hxCoil.HeatExchangerNum);
+                hxCoil.SecAirInNodeNum = HeatRecovery::GetSecondaryInletNode(state, hxCoil.HeatExchangerNum);
+                hxCoil.SecAirOutNodeNum = HeatRecovery::GetSecondaryOutletNode(state, hxCoil.HeatExchangerNum);
             }
 
-            if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:Water") ||
-                Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:Water:DetailedGeometry")) {
-                if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:Water:DetailedGeometry")) {
-                    thisHXCoil.CoolingCoilType_Num = HVAC::Coil_CoolingWaterDetailed;
-                } else if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:Water")) {
-                    thisHXCoil.CoolingCoilType_Num = HVAC::Coil_CoolingWater;
-                }
+            if (hxCoil.coolCoilType == HVAC::CoilType::CoolingWater  ||
+                hxCoil.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
 
-                thisHXCoil.HXAssistedCoilType = CurrentModuleObject;
-                thisHXCoil.HXAssistedCoilType_Num = HVAC::CoilWater_CoolingHXAssisted;
+                hxCoil.coilType = HVAC::CoilType::CoolingWaterHXAssisted;
 
-                //         Check node names in heat exchanger and coil objects for consistency
-                CoolingCoilErrFlag = false;
-                CoolingCoilInletNodeNum =
-                    WaterCoils::GetCoilInletNode(state, thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                CoolingCoilWaterInletNodeNum =
-                    WaterCoils::GetCoilWaterInletNode(state, thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                HVACControllers::GetControllerNameAndIndex(
-                    state, CoolingCoilWaterInletNodeNum, thisHXCoil.ControllerName, thisHXCoil.ControllerIndex, CoolingCoilErrFlag);
-                if (CoolingCoilErrFlag) ShowContinueError(state, format("...occurs in {} \"{}\"", CurrentModuleObject, thisHXCoil.Name));
-                if (SupplyAirOutletNode != CoolingCoilInletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
-                    ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
-                    ShowContinueError(state,
-                                      format("The supply air outlet node name in heat exchanger = {}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
-                    ShowContinueError(
-                        state,
-                        format("must match the cooling coil inlet node name in = {}=\"{}\"", thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName));
-                    ShowContinueError(state,
-                                      format("Heat exchanger supply air outlet node name =\"{}\"", state.dataLoopNodes->NodeID(SupplyAirOutletNode)));
-                    ShowContinueError(state,
-                                      format("Cooling coil air inlet node name = \"{}\"", state.dataLoopNodes->NodeID(CoolingCoilInletNodeNum)));
-                    ErrorsFound = true;
-                }
-                CoolingCoilErrFlag = false;
-                CoolingCoilOutletNodeNum =
-                    WaterCoils::GetCoilOutletNode(state, thisHXCoil.CoolingCoilType, thisHXCoil.CoolingCoilName, CoolingCoilErrFlag);
-                if (CoolingCoilErrFlag) ShowContinueError(state, format("...occurs in {} \"{}\"", CurrentModuleObject, thisHXCoil.Name));
-                if (SecondaryAirInletNode != CoolingCoilOutletNodeNum) {
-                    ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
-                    ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
-                    ShowContinueError(state,
-                                      format("The secondary air inlet node name in heat exchanger = {}=\"{}\"",
-                                             HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                             thisHXCoil.HeatExchangerName));
-                    ShowContinueError(state,
-                                      format("must match the cooling coil air outlet node name in = {}=\"{}\".",
-                                             thisHXCoil.CoolingCoilType,
-                                             thisHXCoil.CoolingCoilName));
-                    ShowContinueError(
-                        state, format("Heat exchanger secondary air inlet node name = \"{}\".", state.dataLoopNodes->NodeID(SecondaryAirInletNode)));
-                    ShowContinueError(state,
-                                      format("Cooling coil air outlet node name = \"{}\".", state.dataLoopNodes->NodeID(CoolingCoilOutletNodeNum)));
+                hxCoil.CoolCoilNum = WaterCoils::GetCoilIndex(state, hxCoil.CoolCoilName);
+                if (hxCoil.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(5), hxCoil.CoolCoilName);
                     ErrorsFound = true;
+                } else {
+                    hxCoil.Capacity = WaterCoils::GetCoilCapacity(state, hxCoil.CoolCoilNum);
+                    hxCoil.MaxWaterFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, hxCoil.CoolCoilNum);
+                    
+                    //         Check node names in heat exchanger and coil objects for consistency
+                    hxCoil.CoolCoilInNodeNum = WaterCoils::GetCoilAirInletNode(state, hxCoil.CoolCoilNum);
+                    hxCoil.CoolCoilWaterInNodeNum = WaterCoils::GetCoilWaterInletNode(state, hxCoil.CoolCoilNum);
+                    hxCoil.CoolCoilWaterOutNodeNum = WaterCoils::GetCoilWaterOutletNode(state, hxCoil.CoolCoilNum);
+                
+                    HVACControllers::GetControllerNameAndIndex(
+                        state, hxCoil.CoolCoilWaterInNodeNum, hxCoil.ControllerName, hxCoil.ControllerIndex, CoolingCoilErrFlag);
+                    if (CoolingCoilErrFlag) ShowContinueError(state, format("...occurs in {} \"{}\"", CurrentModuleObject, hxCoil.Name));
+
+                    if (hxCoil.SupplyAirOutNodeNum != hxCoil.CoolCoilInNodeNum) {
+                        ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
+                        ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
+                        ShowContinueError(state,
+                                          format("The supply air outlet node name in heat exchanger = {}=\"{}\"",
+                                                 HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                                 hxCoil.HeatExchangerName));
+                        ShowContinueError(
+                                          state,
+                                          format("must match the cooling coil inlet node name in = {}=\"{}\"",
+                                                 HVAC::coilTypeNames[(int)hxCoil.coolCoilType], hxCoil.CoolCoilName));
+                        ShowContinueError(state,
+                                          format("Heat exchanger supply air outlet node name =\"{}\"", s_node->NodeID(hxCoil.SupplyAirOutNodeNum)));
+                        ShowContinueError(state,
+                                          format("Cooling coil air inlet node name = \"{}\"", s_node->NodeID(hxCoil.CoolCoilInNodeNum)));
+                        ErrorsFound = true;
+                    }
+                    CoolingCoilErrFlag = false;
+
+                    hxCoil.CoolCoilOutNodeNum = WaterCoils::GetCoilAirOutletNode(state, hxCoil.CoolCoilNum);
+                    if (hxCoil.SecAirInNodeNum != hxCoil.CoolCoilOutNodeNum) {
+                         ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, hxCoil.Name));
+                         ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object.");
+                         ShowContinueError(state,
+                                           format("The secondary air inlet node name in heat exchanger = {}=\"{}\"",
+                                                  HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                                  hxCoil.HeatExchangerName));
+                         ShowContinueError(state,
+                                           format("must match the cooling coil air outlet node name in = {}=\"{}\".",
+                                                  HVAC::coilTypeNames[(int)hxCoil.coolCoilType],
+                                                  hxCoil.CoolCoilName));
+                         ShowContinueError(
+                                           state, format("Heat exchanger secondary air inlet node name = \"{}\".", s_node->NodeID(hxCoil.SecAirInNodeNum)));
+                         ShowContinueError(state,
+                                           format("Cooling coil air outlet node name = \"{}\".", s_node->NodeID(hxCoil.CoolCoilOutNodeNum)));
+                         ErrorsFound = true;
+                    }
                 }
-
             } else {
-                ShowWarningError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name));
-                ShowContinueError(state, format("Invalid {}=\"{}\"", cAlphaFields(4), thisHXCoil.CoolingCoilType));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(4), AlphArray(4));
                 ErrorsFound = true;
             }
             BranchNodeConnections::TestCompSet(state,
-                                               thisHXCoil.HXAssistedCoilType,
-                                               thisHXCoil.Name,
-                                               state.dataLoopNodes->NodeID(SupplyAirInletNode),
-                                               state.dataLoopNodes->NodeID(SecondaryAirOutletNode),
+                                               HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                               hxCoil.Name,
+                                               s_node->NodeID(hxCoil.SupplyAirInNodeNum),
+                                               s_node->NodeID(hxCoil.SecAirOutNodeNum),
                                                "Air Nodes");
 
-            thisHXCoil.HXAssistedCoilInletNodeNum =
+            hxCoil.HXCoilInNodeNum =
                 NodeInputManager::GetOnlySingleNode(state,
-                                                    state.dataLoopNodes->NodeID(SupplyAirInletNode),
+                                                    s_node->NodeID(hxCoil.SupplyAirInNodeNum),
                                                     ErrorsFound,
                                                     DataLoopNode::ConnectionObjectType::CoilSystemCoolingWaterHeatExchangerAssisted,
-                                                    thisHXCoil.Name,
+                                                    hxCoil.Name,
                                                     DataLoopNode::NodeFluidType::Air,
                                                     DataLoopNode::ConnectionType::Inlet,
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
             // no need to capture CoolingCoilInletNodeNum as the return value, it's not used anywhere
             NodeInputManager::GetOnlySingleNode(state,
-                                                state.dataLoopNodes->NodeID(SupplyAirOutletNode),
+                                                s_node->NodeID(hxCoil.SupplyAirOutNodeNum),
                                                 ErrorsFound,
                                                 DataLoopNode::ConnectionObjectType::CoilSystemCoolingWaterHeatExchangerAssisted,
-                                                state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).Name,
+                                                state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum).Name,
                                                 DataLoopNode::NodeFluidType::Air,
                                                 DataLoopNode::ConnectionType::Internal,
                                                 NodeInputManager::CompFluidStream::Primary,
                                                 DataLoopNode::ObjectIsParent);
-            thisHXCoil.HXExhaustAirInletNodeNum =
+            hxCoil.HXCoilExhaustAirInNodeNum =
                 NodeInputManager::GetOnlySingleNode(state,
-                                                    state.dataLoopNodes->NodeID(SecondaryAirInletNode),
+                                                    s_node->NodeID(hxCoil.SecAirInNodeNum),
                                                     ErrorsFound,
                                                     DataLoopNode::ConnectionObjectType::CoilSystemCoolingWaterHeatExchangerAssisted,
-                                                    thisHXCoil.Name,
+                                                    hxCoil.Name,
                                                     DataLoopNode::NodeFluidType::Air,
                                                     DataLoopNode::ConnectionType::Internal,
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
-            thisHXCoil.HXAssistedCoilOutletNodeNum =
+            hxCoil.HXCoilOutNodeNum =
                 NodeInputManager::GetOnlySingleNode(state,
-                                                    state.dataLoopNodes->NodeID(SecondaryAirOutletNode),
+                                                    s_node->NodeID(hxCoil.SecAirOutNodeNum),
                                                     ErrorsFound,
                                                     DataLoopNode::ConnectionObjectType::CoilSystemCoolingWaterHeatExchangerAssisted,
-                                                    thisHXCoil.Name,
+                                                    hxCoil.Name,
                                                     DataLoopNode::NodeFluidType::Air,
                                                     DataLoopNode::ConnectionType::Outlet,
                                                     NodeInputManager::CompFluidStream::Primary,
@@ -771,29 +755,29 @@ namespace HVACHXAssistedCoolingCoil {
 
             // Add cooling coil to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisHXCoil.HXAssistedCoilType,
-                                                 thisHXCoil.Name,
-                                                 thisHXCoil.CoolingCoilType,
-                                                 thisHXCoil.CoolingCoilName,
-                                                 state.dataLoopNodes->NodeID(SupplyAirOutletNode),
-                                                 state.dataLoopNodes->NodeID(SecondaryAirInletNode),
+                                                 HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                                 hxCoil.Name,
+                                                 HVAC::coilTypeNames[(int)hxCoil.coolCoilType],
+                                                 hxCoil.CoolCoilName,
+                                                 s_node->NodeID(hxCoil.SupplyAirOutNodeNum),
+                                                 s_node->NodeID(hxCoil.SecAirInNodeNum),
                                                  "Air Nodes");
             // Add heat exchanger to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisHXCoil.HXAssistedCoilType,
-                                                 thisHXCoil.Name,
-                                                 HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                                 thisHXCoil.HeatExchangerName,
-                                                 state.dataLoopNodes->NodeID(SupplyAirInletNode),
-                                                 state.dataLoopNodes->NodeID(SupplyAirOutletNode),
+                                                 HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                                 hxCoil.Name,
+                                                 HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                                 hxCoil.HeatExchangerName,
+                                                 s_node->NodeID(hxCoil.SupplyAirInNodeNum),
+                                                 s_node->NodeID(hxCoil.SupplyAirOutNodeNum),
                                                  "Process Air Nodes");
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisHXCoil.HXAssistedCoilType,
-                                                 thisHXCoil.Name,
-                                                 HVAC::hxTypeNames[(int)thisHXCoil.hxType],
-                                                 thisHXCoil.HeatExchangerName,
-                                                 state.dataLoopNodes->NodeID(SecondaryAirInletNode),
-                                                 state.dataLoopNodes->NodeID(SecondaryAirOutletNode),
+                                                 HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                                 hxCoil.Name,
+                                                 HVAC::hxTypeNames[(int)hxCoil.hxType],
+                                                 hxCoil.HeatExchangerName,
+                                                 s_node->NodeID(hxCoil.SecAirInNodeNum),
+                                                 s_node->NodeID(hxCoil.SecAirOutNodeNum),
                                                  "Secondary Air Nodes");
 
         } // End of the Coil:Water:CoolingHXAssisted Loop
@@ -830,20 +814,22 @@ namespace HVACHXAssistedCoolingCoil {
         // METHODOLOGY EMPLOYED:
         //  Uses the status flags to trigger initializations.
 
+        auto &s_node = state.dataLoopNodes;
+      
         // Do these initializations every time
-        auto &thisHXCoil = state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum);
-        thisHXCoil.MassFlowRate = state.dataLoopNodes->Node(thisHXCoil.HXAssistedCoilInletNodeNum).MassFlowRate;
+        auto &hxCoil = state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum);
+        hxCoil.MassFlowRate = s_node->Node(hxCoil.HXCoilInNodeNum).MassFlowRate;
 
-        if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+        if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDX) {
             //
             // state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex]
             //     .outletAirDryBulbTemp = 0.0;
             // state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].outletAirHumRat =
             //     0.0;
-        } else if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-            state.dataDXCoils->DXCoilFullLoadOutAirTemp(thisHXCoil.CoolingCoilIndex) = 0.0;
-            state.dataDXCoils->DXCoilFullLoadOutAirHumRat(thisHXCoil.CoolingCoilIndex) = 0.0;
-        } else if (thisHXCoil.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+        } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+            state.dataDXCoils->DXCoilFullLoadOutAirTemp(hxCoil.CoolCoilNum) = 0.0;
+            state.dataDXCoils->DXCoilFullLoadOutAirHumRat(hxCoil.CoolCoilNum) = 0.0;
+        } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
             //
         }
     }
@@ -877,22 +863,25 @@ namespace HVACHXAssistedCoolingCoil {
         // SUBROUTINE PARAMETER DEFINITIONS:
         int constexpr MaxIter(50); // Maximum number of iterations
 
-        int CompanionCoilIndexNum; // Index to DX coil
+        int CompanionCoilNum; // Index to DX coil
 
-        auto &thisHXCoil = state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum);
-        Real64 AirMassFlow = thisHXCoil.MassFlowRate;
+        auto &s_node = state.dataLoopNodes;
+        
+        auto &hxCoil = state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum);
+        Real64 AirMassFlow = hxCoil.MassFlowRate;
         Real64 Error = 1.0;       // Initialize error (CoilOutputTemp last iteration minus current CoilOutputTemp)
         Real64 ErrorLast = Error; // initialize variable used to test loop termination
         int Iter = 0;             // Initialize iteration counter to zero
 
         // Set mass flow rate at inlet of exhaust side of heat exchanger to supply side air mass flow rate entering this compound object
-        state.dataLoopNodes->Node(thisHXCoil.HXExhaustAirInletNodeNum).MassFlowRate = AirMassFlow;
+        s_node->Node(hxCoil.HXCoilExhaustAirInNodeNum).MassFlowRate = AirMassFlow;
 
-        if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_Cooling || thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed ||
-            thisHXCoil.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            CompanionCoilIndexNum = thisHXCoil.CoolingCoilIndex;
+        if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDX ||
+            hxCoil.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+            hxCoil.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            CompanionCoilNum = hxCoil.CoolCoilNum;
         } else {
-            CompanionCoilIndexNum = 0;
+            CompanionCoilNum = 0;
         }
 
         // First call to RegulaFalsi uses PLR=0. Nodes are typically setup at full output on this call.
@@ -900,44 +889,38 @@ namespace HVACHXAssistedCoolingCoil {
         // Reset node data to minimize iteration. This initialization reduces the number of iterations by 50%.
         // CAUTION: Do not use Node(x) = Node(y) here, this can overwrite the coil outlet node setpoint.
         if (PartLoadRatio == 0.0) {
-            state.dataLoopNodes->Node(thisHXCoil.HXExhaustAirInletNodeNum).Temp =
-                state.dataLoopNodes->Node(thisHXCoil.HXAssistedCoilInletNodeNum).Temp;
-            state.dataLoopNodes->Node(thisHXCoil.HXExhaustAirInletNodeNum).HumRat =
-                state.dataLoopNodes->Node(thisHXCoil.HXAssistedCoilInletNodeNum).HumRat;
-            state.dataLoopNodes->Node(thisHXCoil.HXExhaustAirInletNodeNum).Enthalpy =
-                state.dataLoopNodes->Node(thisHXCoil.HXAssistedCoilInletNodeNum).Enthalpy;
-            state.dataLoopNodes->Node(thisHXCoil.HXExhaustAirInletNodeNum).MassFlowRate =
-                state.dataLoopNodes->Node(thisHXCoil.HXAssistedCoilInletNodeNum).MassFlowRate;
+            s_node->Node(hxCoil.HXCoilExhaustAirInNodeNum).Temp = s_node->Node(hxCoil.HXCoilInNodeNum).Temp;
+            s_node->Node(hxCoil.HXCoilExhaustAirInNodeNum).HumRat = s_node->Node(hxCoil.HXCoilInNodeNum).HumRat;
+            s_node->Node(hxCoil.HXCoilExhaustAirInNodeNum).Enthalpy = s_node->Node(hxCoil.HXCoilInNodeNum).Enthalpy;
+            s_node->Node(hxCoil.HXCoilExhaustAirInNodeNum).MassFlowRate = s_node->Node(hxCoil.HXCoilInNodeNum).MassFlowRate;
         }
 
         // Force at least 2 iterations to pass outlet node information
         while ((std::abs(Error) > 0.0005 && Iter <= MaxIter) || Iter < 2) {
 
             HeatRecovery::SimHeatRecovery(state,
-                                          thisHXCoil.HeatExchangerName,
+                                          hxCoil.HeatExchangerName,
                                           FirstHVACIteration,
-                                          thisHXCoil.HeatExchangerIndex,
+                                          hxCoil.HeatExchangerNum,
                                           fanOp,
                                           PartLoadRatio,
                                           HXUnitOn,
-                                          CompanionCoilIndexNum,
+                                          CompanionCoilNum,
                                           _,
                                           EconomizerFlag,
                                           _,
-                                          thisHXCoil.CoolingCoilType_Num);
+                                          hxCoil.coolCoilType);
 
-            if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+            if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDX) {
 
-                int coolingCoilIndex = thisHXCoil.CoolingCoilIndex;
-
-                int mSingleMode = state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex].getNumModes();
+                int mSingleMode = state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum].getNumModes();
                 bool singleMode = (mSingleMode == 1);
 
-                Real64 mCoolingSpeedNum = state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex]
+                Real64 mCoolingSpeedNum = state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum]
                                               .performance.normalMode.speeds.size(); // used the same for the original variable speed coil
 
                 HVAC::CoilMode coilMode = HVAC::CoilMode::Normal;
-                if (state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex].SubcoolReheatFlag) {
+                if (state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum].SubcoolReheatFlag) {
                     coilMode = HVAC::CoilMode::SubcoolReheat;
                 } else if (DehumidificationMode == HVAC::CoilMode::Enhanced) {
                     coilMode = HVAC::CoilMode::Enhanced;
@@ -955,115 +938,78 @@ namespace HVACHXAssistedCoolingCoil {
                     }
                 }
 
-                state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].simulate(state,
-                                                                                              coilMode, // partially implemented for HXAssistedCoil
-                                                                                              mCoolingSpeedNum,
-                                                                                              CoilPLR,
-                                                                                              fanOp,
-                                                                                              singleMode); //
-
-            } else if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
+                state.dataCoilCoolingDX->coilCoolingDXs[hxCoil.CoolCoilNum].simulate(state,
+                                                                                       coilMode, // partially implemented for HXAssistedCoil
+                                                                                       mCoolingSpeedNum,
+                                                                                       CoilPLR,
+                                                                                       fanOp,
+                                                                                       singleMode); //
+                
+            } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                 DXCoils::SimDXCoil(state,
-                                   thisHXCoil.CoolingCoilName,
+                                   hxCoil.CoolCoilName,
                                    compressorOp,
                                    FirstHVACIteration,
-                                   thisHXCoil.CoolingCoilIndex,
+                                   hxCoil.CoolCoilNum,
                                    fanOp,
                                    PartLoadRatio,
                                    OnOffAirFlow);
-            } else if (thisHXCoil.CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+            } else if (hxCoil.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                 Real64 QZnReq(-1.0);           // Zone load (W), input to variable-speed DX coil
                 Real64 QLatReq(0.0);           // Zone latent load, input to variable-speed DX coil
                 Real64 OnOffAirFlowRatio(1.0); // ratio of compressor on flow to average flow over time step
                 HVAC::CompressorOp compressorOn = compressorOp;
                 if (PartLoadRatio == 0.0) compressorOn = HVAC::CompressorOp::Off;
                 VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                          thisHXCoil.CoolingCoilName,
-                                                          thisHXCoil.CoolingCoilIndex,
+                                                          hxCoil.CoolCoilName,
+                                                          hxCoil.CoolCoilNum,
                                                           fanOp,
                                                           compressorOn,
                                                           PartLoadRatio,
-                                                          thisHXCoil.DXCoilNumOfSpeeds,
+                                                          hxCoil.DXCoilNumOfSpeeds,
                                                           QZnReq,
                                                           QLatReq,
                                                           OnOffAirFlowRatio); // call vs coil model at top speed.
             } else {
-                WaterCoils::SimulateWaterCoilComponents(state, thisHXCoil.CoolingCoilName, FirstHVACIteration, thisHXCoil.CoolingCoilIndex);
+                WaterCoils::SimulateWaterCoilComponents(state, hxCoil.CoolCoilName, FirstHVACIteration, hxCoil.CoolCoilNum);
             }
 
-            Error = state.dataHVACAssistedCC->CoilOutputTempLast - state.dataLoopNodes->Node(thisHXCoil.HXExhaustAirInletNodeNum).Temp;
+            Error = state.dataHVACAssistedCC->CoilOutputTempLast - s_node->Node(hxCoil.HXCoilExhaustAirInNodeNum).Temp;
             if (Iter > 40) { // check for oscillation (one of these being negative and one positive) before hitting max iteration limit
                 if (Error + ErrorLast < 0.000001)
                     Error = 0.0; // result bounced back and forth with same positive and negative result, no possible solution without this check
             }
             ErrorLast = Error;
-            state.dataHVACAssistedCC->CoilOutputTempLast = state.dataLoopNodes->Node(thisHXCoil.HXExhaustAirInletNodeNum).Temp;
+            state.dataHVACAssistedCC->CoilOutputTempLast = s_node->Node(hxCoil.HXCoilExhaustAirInNodeNum).Temp;
             ++Iter;
         }
 
         // Write excessive iteration warning messages
         if (Iter > MaxIter) {
-            if (thisHXCoil.MaxIterCounter < 1) {
-                ++thisHXCoil.MaxIterCounter;
+            if (hxCoil.MaxIterCounter < 1) {
+                ++hxCoil.MaxIterCounter;
                 ShowWarningError(state,
                                  format("{} \"{}\" -- Exceeded max iterations ({}) while calculating operating conditions.",
-                                        thisHXCoil.HXAssistedCoilType,
-                                        thisHXCoil.Name,
+                                        HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                        hxCoil.Name,
                                         MaxIter));
                 ShowContinueErrorTimeStamp(state, "");
             } else {
                 ShowRecurringWarningErrorAtEnd(state,
-                                               thisHXCoil.HXAssistedCoilType + " \"" + thisHXCoil.Name +
-                                                   "\" -- Exceeded max iterations error continues...",
-                                               thisHXCoil.MaxIterIndex);
+                                               format("{} \"{}\" -- Exceeded max iterations error continues...",
+                                                      HVAC::coilTypeNames[(int)hxCoil.coilType],
+                                                      hxCoil.Name),
+                                               hxCoil.MaxIterIndex);
             }
         }
 
-        state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(HXAssistedCoilNum) =
-            state.dataLoopNodes->Node(thisHXCoil.HXAssistedCoilOutletNodeNum).Temp;
-        state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(HXAssistedCoilNum) =
-            state.dataLoopNodes->Node(thisHXCoil.HXAssistedCoilOutletNodeNum).HumRat;
+        state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(HXAssistedCoilNum) = s_node->Node(hxCoil.HXCoilOutNodeNum).Temp;
+        state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(HXAssistedCoilNum) = s_node->Node(hxCoil.HXCoilOutNodeNum).HumRat;
     }
 
     //        End of Reporting subroutines for the HXAssistedCoil Module
     // *****************************************************************************
 
-    void GetHXDXCoilIndex(
-        EnergyPlusData &state, std::string const &HXDXCoilName, int &HXDXCoilIndex, bool &ErrorsFound, std::string_view const CurrentModuleObject)
-    {
-
-        // SUBROUTINE INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   August 2007
-
-        // PURPOSE OF THIS SUBROUTINE:
-        // This subroutine sets an index for a given HX Assisted Cooling Coil -- issues error message if that
-        // HX is not a legal HX Assisted Cooling Coil.
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            HXDXCoilIndex = Util::FindItem(HXDXCoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        } else {
-            HXDXCoilIndex = 0;
-        }
-
-        if (HXDXCoilIndex == 0) {
-            if (!CurrentModuleObject.empty()) {
-                ShowSevereError(state, fmt::format("{}, GetHXDXCoilIndex: HX Assisted Cooling Coil not found={}", CurrentModuleObject, HXDXCoilName));
-            } else {
-                ShowSevereError(state, format("GetHXDXCoilIndex: HX Assisted Cooling Coil not found={}", HXDXCoilName));
-            }
-            ErrorsFound = true;
-        }
-    }
-
     void CheckHXAssistedCoolingCoilSchedule(EnergyPlusData &state,
                                             [[maybe_unused]] std::string const &CompType, // unused1208
                                             std::string_view CompName,
@@ -1093,7 +1039,7 @@ namespace HVACHXAssistedCoolingCoil {
         // Find the correct Coil number
         if (CompIndex == 0) {
             if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-                HXAssistedCoilNum = Util::FindItem(CompName, state.dataHVACAssistedCC->HXAssistedCoil);
+                HXAssistedCoilNum = Util::FindItem(CompName, state.dataHVACAssistedCC->HXAssistedCoils);
             } else {
                 HXAssistedCoilNum = 0;
             }
@@ -1112,342 +1058,105 @@ namespace HVACHXAssistedCoolingCoil {
                                       state.dataHVACAssistedCC->TotalNumHXAssistedCoils,
                                       CompName));
             }
-            if (CompName != state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).Name) {
+            if (CompName != state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum).Name) {
                 ShowFatalError(
                     state,
                     format("CheckHXAssistedCoolingCoilSchedule: Invalid CompIndex passed={}, Coil name={}, stored Coil Name for that index={}",
                            HXAssistedCoilNum,
                            CompName,
-                           state.dataHVACAssistedCC->HXAssistedCoil(HXAssistedCoilNum).Name));
+                           state.dataHVACAssistedCC->HXAssistedCoils(HXAssistedCoilNum).Name));
             }
 
             Value = 1.0; // not scheduled?
         }
     }
 
-    Real64 GetCoilCapacity(EnergyPlusData &state,
-                           std::string const &CoilType, // must match coil types in this module
-                           std::string const &CoilName, // must match coil names for the coil type
-                           bool &ErrorsFound            // set to true if problem
+    Real64 GetHXCoilCapacity(EnergyPlusData &state,
+                             std::string_view const coilType, 
+                             std::string const &coilName, 
+                             bool &ErrorsFound            
     )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   February 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the coil capacity for the given coil and returns it.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
-        // as negative.
-
-        // Return value
-        Real64 CoilCapacity(0.0); // returned capacity of matched coil
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        bool errFlag = false;
-
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
-
-        if (Util::SameString(CoilType, "CoilSystem:Cooling:DX:HeatExchangerAssisted")) {
-            if (WhichCoil != 0) {
-                // coil does not have capacity in input so mine information from DX cooling coil
-
-                if (state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
-                    int coolingCoilDXIndex = state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilIndex;
-                    CoilCapacity = state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilDXIndex].performance.normalMode.ratedGrossTotalCap;
-                } else if (state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-                    CoilCapacity = DXCoils::GetCoilCapacity(state,
-                                                            state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType,
-                                                            state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilName,
-                                                            errFlag);
-                } else if (state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    CoilCapacity =
-                        VariableSpeedCoils::GetCoilCapacityVariableSpeed(state,
-                                                                         state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType,
-                                                                         state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilName,
-                                                                         errFlag);
-                }
-                if (errFlag) {
-                    ShowRecurringWarningErrorAtEnd(
-                        state, "Requested DX Coil from CoilSystem:Cooling:DX:HeatExchangerAssisted not found", state.dataHVACAssistedCC->ErrCount);
-                }
-            }
-        } else if (Util::SameString(CoilType, "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
-            if (WhichCoil != 0) {
-                // coil does not have capacity in input so mine information from DX cooling coil
-                CoilCapacity = WaterCoils::GetWaterCoilCapacity(state,
-                                                                state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType,
-                                                                state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilName,
-                                                                errFlag);
-                if (errFlag) {
-                    ShowRecurringWarningErrorAtEnd(
-                        state, "Requested DX Coil from CoilSystem:Cooling:DX:HeatExchangerAssisted not found", state.dataHVACAssistedCC->ErrCount);
-                }
-            }
-        } else {
-            WhichCoil = 0;
-        }
-
-        if (WhichCoil == 0) {
-            ShowSevereError(state, format("GetCoilCapacity: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ShowContinueError(state, "... Coil Capacity returned as -1000.");
-            ErrorsFound = true;
-            CoilCapacity = -1000.0;
-        }
-
-        if (errFlag) ErrorsFound = true;
-
-        return CoilCapacity;
+        int coilNum = GetCoilIndex(state, coilType, coilName, ErrorsFound);
+        return (coilNum == 0) ? -1000.0 : state.dataHVACAssistedCC->HXAssistedCoils(coilNum).Capacity;
     }
 
-    int GetCoilGroupTypeNum(EnergyPlusData &state,
-                            std::string const &CoilType, // must match coil types in this module
-                            std::string const &CoilName, // must match coil names for the coil type
-                            bool &ErrorsFound,           // set to true if problem
-                            bool const PrintWarning      // prints warning message if true
+    int GetCoilAirInletNode(EnergyPlusData &state,
+                           std::string_view coilType,   
+                           std::string const &coilName, 
+                           bool &ErrorsFound            
     )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         R. Raustad - FSEC
-        //       DATE WRITTEN   August 2008
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the HX coil type and returns it (CoilDX_CoolingHXAssisted, CoilWater_CoolingHXAssisted)
-        // If incorrect coil type or name is given, ErrorsFound is returned as true.
-
-        // FUNCTION LOCAL VARIABLE DECLARATIONS:
-        int WhichCoil;
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        } else {
-            WhichCoil = 0;
-        }
-
-        if (WhichCoil != 0) {
-            // coil does not have capacity in input so mine information from DX cooling coil
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).HXAssistedCoilType_Num;
-        } else {
-            if (PrintWarning) {
-                ShowSevereError(state, format("GetCoilGroupTypeNum: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            }
-            ErrorsFound = true;
-            return 0;
-        }
+        int coilNum = GetCoilIndex(state, coilType, coilName, ErrorsFound);
+        return (coilNum == 0) ? 0 : state.dataHVACAssistedCC->HXAssistedCoils(coilNum).HXCoilInNodeNum;
     }
 
-    int GetCoilObjectTypeNum(EnergyPlusData &state,
-                             std::string const &CoilType, // must match coil types in this module
-                             std::string const &CoilName, // must match coil names for the coil type
-                             bool &ErrorsFound,           // set to true if problem
-                             bool const PrintWarning      // prints warning message if true
+    int GetCoilWaterInletNode(EnergyPlusData &state,
+                              std::string_view const coilType, // must match coil types in this module
+                              std::string const &coilName, // must match coil names for the coil type
+                              bool &ErrorsFound            // set to true if problem
     )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         R. Raustad - FSEC
-        //       DATE WRITTEN   April 2009
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the coil object type for the given coil and returns it.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
-        // as negative.
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
-
-        if (WhichCoil != 0) {
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType_Num;
-        } else {
-            if (PrintWarning) {
-                ShowSevereError(state, format("GetCoilObjectTypeNum: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            }
-            ErrorsFound = true;
-            return 0;
-        }
+        int coilNum = GetCoilIndex(state, coilType, coilName, ErrorsFound);
+        return (coilNum == 0) ? 0 : state.dataHVACAssistedCC->HXAssistedCoils(coilNum).CoolCoilWaterInNodeNum;
     }
 
-    int GetCoilInletNode(EnergyPlusData &state,
-                         std::string_view CoilType,   // must match coil types in this module
-                         std::string const &CoilName, // must match coil names for the coil type
-                         bool &ErrorsFound            // set to true if problem
-    )
+    int GetCoilAirOutletNode(EnergyPlusData &state,
+                             std::string_view CoilType,   // must match coil types in this module
+                             std::string const &CoilName, // must match coil names for the coil type
+                             bool &ErrorsFound            // set to true if problem
+                             )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   February 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the inlet node number.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-        // as zero.
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
-
-        if (WhichCoil != 0) {
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).HXAssistedCoilInletNodeNum;
-        } else {
-            ShowSevereError(state, format("GetCoilInletNode: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            return 0;
-        }
+        int coilNum = GetCoilIndex(state, CoilType, CoilName, ErrorsFound);
+        return (coilNum == 0) ? 0 : state.dataHVACAssistedCC->HXAssistedCoils(coilNum).HXCoilOutNodeNum;
     }
 
-    int GetCoilWaterInletNode(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
+    int GetCoilIndex(EnergyPlusData &state,
+                     std::string_view const coilType, 
+                     std::string const &coilName, 
+                     bool &ErrorsFound            
     )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   April 2011
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the inlet node number.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-        // as zero.
-
-        // Return value
-        int NodeNumber; // returned node number of matched coil
-
         // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
+        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { 
             GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
+            state.dataHVACAssistedCC->GetCoilsInputFlag = false; 
         }
 
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
+        int coilNum = (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) ?
+            Util::FindItem(coilName, state.dataHVACAssistedCC->HXAssistedCoils) : 0;
 
-        if (WhichCoil != 0) {
-            if (state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType_Num == HVAC::Coil_CoolingWater) {
-                NodeNumber = WaterCoils::GetCoilWaterInletNode(state,
-                                                               state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType,
-                                                               state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilName,
-                                                               ErrorsFound);
-            } else if (state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
-                NodeNumber = WaterCoils::GetCoilWaterInletNode(state,
-                                                               state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType,
-                                                               state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilName,
-                                                               ErrorsFound);
-            } else { // even though validated in Get, still check.
-                ShowSevereError(state,
-                                format("GetCoilWaterInletNode: Invalid Cooling Coil for HX Assisted Coil, Type=\"{}\" Name=\"{}\"",
-                                       state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType,
-                                       CoilName));
-                ErrorsFound = true;
-                NodeNumber = 0; // Autodesk:Return Added line to set return value
-            }
-        } else {
-            ShowSevereError(state, format("GetCoilInletNode: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
+        if (coilNum == 0) {
+            ShowSevereError(state, format("GetHXCoilIndex: Could not find Coil, Type=\"{}\" Name=\"{}", coilType, coilName));
             ErrorsFound = true;
-            NodeNumber = 0;
         }
 
-        return NodeNumber;
+        return coilNum;
     }
 
-    int GetCoilOutletNode(EnergyPlusData &state,
-                          std::string_view CoilType,   // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
-    )
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         R. Raustad
-        //       DATE WRITTEN   August 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the outlet node number.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-        // as zero.
-
         // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
+        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { 
             GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
+            state.dataHVACAssistedCC->GetCoilsInputFlag = false; 
         }
 
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
-
-        if (WhichCoil != 0) {
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).HXAssistedCoilOutletNodeNum;
-        } else {
-            ShowSevereError(state, format("GetCoilOutletNode: Could not find Coil, Type=\"{}\" Name=\"{}", CoilType, CoilName));
-            ErrorsFound = true;
-            return 0;
-        }
+        return Util::FindItem(coilName, state.dataHVACAssistedCC->HXAssistedCoils);
     }
-
-    std::string GetHXDXCoilType(EnergyPlusData &state,
-                                std::string const &CoilType, // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
+  
+    bool VerifyHeatExchangerParent(EnergyPlusData &state,
+                                   std::string const &HXType, // must match coil types in this module
+                                   std::string const &HXName  // must match coil names for the coil type
     )
     {
 
         // FUNCTION INFORMATION:
-        //       AUTHOR         R. Raustad, FSEC
-        //       DATE WRITTEN   September 2015
+        //       AUTHOR         Lixing Gu
+        //       DATE WRITTEN   January 2009
 
         // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the cooling coil type.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and the name
-        // is returned as blank
+        // This function looks up the given heat exchanger name and type and returns true or false.
 
         // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
         if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
@@ -1459,328 +1168,93 @@ namespace HVACHXAssistedCoolingCoil {
 
         int WhichCoil = 0;
         if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
+            WhichCoil = Util::FindItem(HXName, state.dataHVACAssistedCC->HXAssistedCoils, &HXAssistedCoilParameters::HeatExchangerName);
         }
 
         if (WhichCoil != 0) {
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType;
-        } else {
-            ShowSevereError(state, format("Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            return "";
+            if (Util::SameString(HVAC::hxTypeNames[(int)state.dataHVACAssistedCC->HXAssistedCoils(WhichCoil).hxType], HXType)) {
+                return true;
+            }
         }
+        return false;
     }
 
-    std::string GetHXDXCoilName(EnergyPlusData &state,
-                                std::string_view CoilType,   // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
-    )
-    {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   February 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the cooling coil name.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and the name
-        // is returned as blank
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
+    //        End of Utility subroutines for the HXAssistedCoil Module
+    // *****************************************************************************
 
-        if (WhichCoil != 0) {
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilName;
-        } else {
-            ShowSevereError(state, format("Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            return "";
-        }
+    HVAC::CoilType GetCoilChildCoilType(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).coolCoilType;
     }
 
-    int GetActualDXCoilIndex(EnergyPlusData &state,
-                             std::string const &CoilType, // must match coil types in this module
-                             std::string const &CoilName, // must match coil names for the coil type
-                             bool &ErrorsFound            // set to true if problem
-    )
+    std::string GetCoilChildCoilName(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   February 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the cooling coil name.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and the name
-        // is returned as blank
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
-
-        if (WhichCoil != 0) {
-            // this should be the index to the DX cooling coil object, not the HXAssisted object
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilIndex;
-        } else {
-            ShowSevereError(state, format("Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            return 0;
-        }
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).CoolCoilName;
     }
 
-    std::string GetHXCoilType(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    )
+    int GetCoilChildCoilIndex(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Fred Buhl
-        //       DATE WRITTEN   June 2009
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the cooling coil type.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and the cooling
-        // coil type is returned as blank.
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
-
-        if (WhichCoil != 0) {
-            return state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType;
-        } else {
-            ShowSevereError(state, format("Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            return "";
-        }
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).CoolCoilNum;
     }
-
-    void GetHXCoilTypeAndName(EnergyPlusData &state,
-                              std::string const &CoilType,  // must match coil types in this module
-                              std::string const &CoilName,  // must match coil names for the coil type
-                              bool &ErrorsFound,            // set to true if problem
-                              std::string &CoolingCoilType, // returned type of cooling coil
-                              std::string &CoolingCoilName  // returned name of cooling coil
-    )
+  
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, int const coilNum)
     {
-
-        // SUBROUTINE INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   Oct 2011
-
-        // PURPOSE OF THIS SUBROUTINE:
-        // Need to get child coil type and name.
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-        }
-
-        if (WhichCoil != 0) {
-            CoolingCoilType = state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType;
-            CoolingCoilName = state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilName;
-        } else {
-            ShowSevereError(state, format("Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            CoolingCoilType = "";
-            CoolingCoilName = "";
-        }
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).MaxWaterFlowRate;
     }
 
-    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state,
-                                   std::string_view CoilType,   // must match coil types in this module
-                                   std::string const &CoilName, // must match coil names for the coil type
-                                   bool &ErrorsFound            // set to true if problem
-    )
+    Real64 GetCoilMaxAirFlowRate(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   November 2006
-        //       MODIFIED       R. Raustad, April 2009 - added water coil ELSE IF
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the max water flow rate for the given coil and returns it.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
-        // as negative.
-
-        // Return value
-        Real64 MaxWaterFlowRate; // returned max water flow rate of matched coil
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-
-            int WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-
-            if (Util::SameString(CoilType, "CoilSystem:Cooling:DX:HeatExchangerAssisted")) {
-                if (WhichCoil != 0) {
-                    // coil does not specify MaxWaterFlowRate
-                    MaxWaterFlowRate = 0.0;
-                    ShowRecurringWarningErrorAtEnd(state,
-                                                   "Requested Max Water Flow Rate from CoilSystem:Cooling:DX:HeatExchangerAssisted N/A",
-                                                   state.dataHVACAssistedCC->ErrCount2);
-                }
-            } else if (Util::SameString(CoilType, "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
-                if (WhichCoil != 0) {
-                    MaxWaterFlowRate =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, CoilType, GetHXDXCoilName(state, CoilType, CoilName, ErrorsFound), ErrorsFound);
-                }
-            } else {
-                WhichCoil = 0;
-            }
-
-            if (WhichCoil == 0) {
-                ShowSevereError(state, format("GetCoilMaxWaterFlowRate: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-                ErrorsFound = true;
-                MaxWaterFlowRate = -1000.0;
-            }
-        } else {
-            ShowSevereError(state, format("GetCoilMaxWaterFlowRate: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            MaxWaterFlowRate = -1000.0;
-        }
-
-        return MaxWaterFlowRate;
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).MaxAirFlowRate;
     }
-
-    Real64 GetHXCoilAirFlowRate(EnergyPlusData &state,
-                                std::string const &CoilType, // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
-    )
+  
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   September 2013
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the max air flow rate for the given HX and returns it.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
-        // as negative.
-
-        // Return value
-        Real64 MaxAirFlowRate; // returned max air flow rate of matched HX
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
-
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-
-            int WhichCoil = Util::FindItem(CoilName, state.dataHVACAssistedCC->HXAssistedCoil);
-
-            if (Util::SameString(CoilType, "CoilSystem:Cooling:DX:HeatExchangerAssisted") ||
-                Util::SameString(CoilType, "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
-                if (WhichCoil != 0) {
-                    MaxAirFlowRate =
-                        HeatRecovery::GetSupplyAirFlowRate(state, state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).HeatExchangerName, ErrorsFound);
-                }
-            } else {
-                WhichCoil = 0;
-            }
-
-            if (WhichCoil == 0) {
-                ShowSevereError(state, format("GetHXCoilAirFlowRate: Could not find HX, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-                ErrorsFound = true;
-                MaxAirFlowRate = -1000.0;
-            }
-        } else {
-            ShowSevereError(state, format("GetHXCoilAirFlowRate: Could not find HX, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            MaxAirFlowRate = -1000.0;
-        }
-
-        return MaxAirFlowRate;
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).Capacity;
     }
 
-    bool VerifyHeatExchangerParent(EnergyPlusData &state,
-                                   std::string const &HXType, // must match coil types in this module
-                                   std::string const &HXName  // must match coil names for the coil type
-    )
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
     {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).HXCoilInNodeNum;
+    }
 
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Lixing Gu
-        //       DATE WRITTEN   January 2009
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given heat exchanger name and type and returns true or false.
-
-        // Obtains and allocates HXAssistedCoolingCoil related parameters from input file
-        if (state.dataHVACAssistedCC->GetCoilsInputFlag) { // First time subroutine has been called, get input data
-            // Get the HXAssistedCoolingCoil input
-            GetHXAssistedCoolingCoilInput(state);
-            state.dataHVACAssistedCC->GetCoilsInputFlag =
-                false; // Set logic flag to disallow getting the input data on future calls to this subroutine
-        }
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).HXCoilOutNodeNum;
+    }
+  
+    int GetCoilWaterInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).CoolCoilWaterInNodeNum;
+    }
 
-        int WhichCoil = 0;
-        if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
-            WhichCoil = Util::FindItem(HXName, state.dataHVACAssistedCC->HXAssistedCoil, &HXAssistedCoilParameters::HeatExchangerName);
-        }
+    int GetCoilWaterOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).CoolCoilWaterOutNodeNum;
+    }
 
-        if (WhichCoil != 0) {
-            if (Util::SameString(HVAC::hxTypeNames[(int)state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).hxType], HXType)) {
-                return true;
-            }
-        }
-        return false;
+    int GetCoilCondenserInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return state.dataHVACAssistedCC->HXAssistedCoils(coilNum).CoolCoilCondenserInNodeNum;
     }
 
-    //        End of Utility subroutines for the HXAssistedCoil Module
-    // *****************************************************************************
 
-} // namespace HVACHXAssistedCoolingCoil
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum) 
+    {
+        assert(coilNum > 0 && coilNum <= state.dataHVACAssistedCC->HXAssistedCoils.size());
+        return 1.0; // Not scheduled? Always available?
+    }
 
+} // namespace HXAssistCoil
+  
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/HVACHXAssistedCoolingCoil.hh b/src/EnergyPlus/HVACHXAssistedCoolingCoil.hh
index a427fbfaf94..ce4afd3dc9c 100644
--- a/src/EnergyPlus/HVACHXAssistedCoolingCoil.hh
+++ b/src/EnergyPlus/HVACHXAssistedCoolingCoil.hh
@@ -62,42 +62,52 @@ namespace EnergyPlus {
 // Forward declarations
 struct EnergyPlusData;
 
-namespace HVACHXAssistedCoolingCoil {
+namespace HXAssistCoil {
 
     struct HXAssistedCoilParameters
     {
         // Members
-        std::string HXAssistedCoilType; // Type of HXAssistedCoolingCoil
-        int HXAssistedCoilType_Num;     // Numeric equivalent for hx assisted coil
         std::string Name;               // Name of the HXAssistedCoolingCoil
-        std::string CoolingCoilType;    // Cooling coil type must be DetailedFlatCooling
-        //  or Coil:DX:CoolingBypassFactorEmpirical
-        int CoolingCoilType_Num;     // Numeric Equivalent for cooling coil
-        std::string CoolingCoilName; // Cooling coil name
-        int CoolingCoilIndex;
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid; // coilType of the parent object
+        int HXCoilInNodeNum = 0;              // Inlet node to HXAssistedCoolingCoil compound object
+        int HXCoilOutNodeNum = 0;             // Outlet node to HXAssistedCoolingCoil compound object
+      
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid; // Must be DetailedFlatCooling Coil:DX:CoolingBypassFactorEmpirical
+        std::string CoolCoilName; // Cooling coil name
+        int CoolCoilNum = 0;
+
+        int CoolCoilCondenserInNodeNum = 0;
+        int CoolCoilWaterInNodeNum = 0;
+        int CoolCoilWaterOutNodeNum = 0;
+        int CoolCoilInNodeNum = 0;
+        int CoolCoilOutNodeNum = 0;
+      
         int DXCoilNumOfSpeeds; // number of speed levels for variable speed DX coil
         // Heat Exchanger type must be HeatExchanger:AirToAir:FlatPlate,
         // HeatExchanger:AirToAir:SensibleAndLatent or
         // HeatExchanger:Desiccant:BalancedFlow
+
+        Real64 Capacity = 0.0;
+      
         HVAC::HXType hxType = HVAC::HXType::Invalid; // Numeric Equivalent for heat exchanger
         std::string HeatExchangerName;               // Heat Exchanger name
-        int HeatExchangerIndex;                      // Heat Exchanger index
-        int HXAssistedCoilInletNodeNum;              // Inlet node to HXAssistedCoolingCoil compound object
-        int HXAssistedCoilOutletNodeNum;             // Outlet node to HXAssistedCoolingCoil compound object
-        int HXExhaustAirInletNodeNum;                // Inlet node number for air-to-air heat exchanger
-        Real64 MassFlowRate;                         // Mass flow rate through HXAssistedCoolingCoil compound object
-        int MaxIterCounter;                          // used in warning messages
-        int MaxIterIndex;                            // used in warning messages
-        int ControllerIndex;                         // index to water coil controller
-        std::string ControllerName;                  // name of water coil controller
-
-        // Default Constructor
-        HXAssistedCoilParameters()
-            : HXAssistedCoilType_Num(0), CoolingCoilType_Num(0), CoolingCoilIndex(0), DXCoilNumOfSpeeds(0), HeatExchangerIndex(0),
-              HXAssistedCoilInletNodeNum(0), HXAssistedCoilOutletNodeNum(0), HXExhaustAirInletNodeNum(0), MassFlowRate(0.0), MaxIterCounter(0),
-              MaxIterIndex(0), ControllerIndex(0)
-        {
-        }
+        int HeatExchangerNum = 0;                      // Heat Exchanger index
+
+        int SupplyAirInNodeNum = 0;
+        int SupplyAirOutNodeNum = 0;
+        int SecAirInNodeNum = 0;
+        int SecAirOutNodeNum = 0;
+      
+        int HXCoilExhaustAirInNodeNum = 0;                // Inlet node number for air-to-air heat exchanger
+
+        Real64 MassFlowRate = 0.0;                         // Mass flow rate through HXAssistedCoolingCoil compound object
+        int MaxIterCounter = 0;                          // used in warning messages
+        int MaxIterIndex = 0;                            // used in warning messages
+        int ControllerIndex = 0;                         // index to water coil controller
+        std::string ControllerName;                      // name of water coil controller
+
+        Real64 MaxWaterFlowRate = 0.0;
+        Real64 MaxAirFlowRate = 0.0;
     };
 
     void
@@ -116,6 +126,21 @@ namespace HVACHXAssistedCoolingCoil {
                              ObjexxFCL::Optional<Real64 const> LoadSHR = _                       // Optional coil SHR pass over
     );
 
+    void
+    SimHXAssistedCoolingCoil(EnergyPlusData &state,
+                             int const coilNum,
+                             bool const FirstHVACIteration,       // FirstHVACIteration flag
+                             HVAC::CompressorOp compressorOp,     // compressor operation; 1=on, 0=off
+                             Real64 const PartLoadRatio,          // Part load ratio of Coil:DX:CoolingBypassFactorEmpirical
+                             HVAC::FanOp const fanOp,                           // Allows the parent object to control fan operation
+                             ObjexxFCL::Optional_bool_const HXUnitEnable = _,   // flag to enable heat exchanger heat recovery
+                             ObjexxFCL::Optional<Real64 const> OnOffAFR = _,    // Ratio of compressor ON air mass flow rate to AVERAGE over time step
+                             ObjexxFCL::Optional_bool_const EconomizerFlag = _, // OA sys or air loop economizer status
+                             ObjexxFCL::Optional<Real64> QTotOut = _,           // the total cooling output of unit
+                             ObjexxFCL::Optional<HVAC::CoilMode const> DehumidificationMode = _, // Optional dehumbidication mode
+                             ObjexxFCL::Optional<Real64 const> LoadSHR = _                       // Optional coil SHR pass over
+    );
+  
     void GetHXAssistedCoolingCoilInput(EnergyPlusData &state);
 
     void InitHXAssistedCoolingCoil(EnergyPlusData &state, int const HXAssistedCoilNum); // index for HXAssistedCoolingCoil
@@ -134,106 +159,77 @@ namespace HVACHXAssistedCoolingCoil {
                               [[maybe_unused]] ObjexxFCL::Optional<Real64 const> LoadSHR = _      // Optional coil SHR pass over
     );
 
-    void GetHXDXCoilIndex(EnergyPlusData &state,
-                          std::string const &HXDXCoilName,
-                          int &HXDXCoilIndex,
-                          bool &ErrorsFound,
-                          std::string_view const CurrentModuleObject = {});
-
-    void CheckHXAssistedCoolingCoilSchedule(EnergyPlusData &state,
-                                            std::string const &CompType, // unused1208
-                                            std::string_view CompName,
-                                            Real64 &Value,
-                                            int &CompIndex);
+    int GetCoilIndex(EnergyPlusData &state,
+                     std::string_view const coilType,
+                     std::string const &coilName,
+                     bool &ErrorsFound);
 
+#ifdef OLD_API
     Real64 GetCoilCapacity(EnergyPlusData &state,
-                           std::string const &CoilType, // must match coil types in this module
-                           std::string const &CoilName, // must match coil names for the coil type
-                           bool &ErrorsFound            // set to true if problem
-    );
+                             std::string_view const coilType,
+                             std::string const &coilName,
+                             bool &ErrorsFound);
 
-    int GetCoilGroupTypeNum(EnergyPlusData &state,
-                            std::string const &CoilType,   // must match coil types in this module
-                            std::string const &CoilName,   // must match coil names for the coil type
-                            bool &ErrorsFound,             // set to true if problem
-                            bool const PrintWarning = true // prints warning message if true
-    );
+    HVAC::CoilType GetCoilChildCoilType(EnergyPlusData &state,
+                                         std::string_view const coilType,
+                                         std::string const &coilName, 
+                                         bool &ErrorsFound);
 
-    int GetCoilObjectTypeNum(EnergyPlusData &state,
-                             std::string const &CoilType,   // must match coil types in this module
-                             std::string const &CoilName,   // must match coil names for the coil type
-                             bool &ErrorsFound,             // set to true if problem
-                             bool const PrintWarning = true // prints warning message if true
-    );
+    std::string GetCoilChildCoilName(EnergyPlusData &state,
+                                      std::string_view const coilType,
+                                      std::string const &coilName, 
+                                      bool &ErrorsFound);
 
-    int GetCoilInletNode(EnergyPlusData &state,
-                         std::string_view CoilType,   // must match coil types in this module
-                         std::string const &CoilName, // must match coil names for the coil type
-                         bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilChildCoilIndex(EnergyPlusData &state,
+                              std::string_view const coilType,
+                              std::string const &coilName, 
+                              bool &ErrorsFound);
+  
+    int GetCoilAirInletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilWaterInletNode(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilAirOutletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilOutletNode(EnergyPlusData &state,
-                          std::string_view CoilType,   // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilCondenserInletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
+  
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    std::string GetHXDXCoilType(EnergyPlusData &state,
-                                std::string const &CoilType, // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
-    );
+    Real64 GetCoilMaxAirFlowRate(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    std::string GetHXDXCoilName(EnergyPlusData &state,
-                                std::string_view CoilType,   // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
-    );
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, std::string_view const compType, std::string const &coilName, bool &ErrorsFound);
+#endif // OLD_API
+  
+    // New API
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
 
-    int GetActualDXCoilIndex(EnergyPlusData &state,
-                             std::string const &CoilType, // must match coil types in this module
-                             std::string const &CoilName, // must match coil names for the coil type
-                             bool &ErrorsFound            // set to true if problem
-    );
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum);
 
-    std::string GetHXCoilType(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    );
+    Real64 GetCoilMaxAirFlowRate(EnergyPlusData &state, int const coilNum);
 
-    void GetHXCoilTypeAndName(EnergyPlusData &state,
-                              std::string const &CoilType,  // must match coil types in this module
-                              std::string const &CoilName,  // must match coil names for the coil type
-                              bool &ErrorsFound,            // set to true if problem
-                              std::string &CoolingCoilType, // returned type of cooling coil
-                              std::string &CoolingCoilName  // returned name of cooling coil
-    );
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, int const coilNum);
 
-    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state,
-                                   std::string_view CoilType,   // must match coil types in this module
-                                   std::string const &CoilName, // must match coil names for the coil type
-                                   bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
 
-    Real64 GetHXCoilAirFlowRate(EnergyPlusData &state,
-                                std::string const &CoilType, // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilCondenserInletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilWaterInletNode(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilWaterOutletNode(EnergyPlusData &state, int const coilNum);
+
+    HVAC::CoilType GetCoilChildCoilType(EnergyPlusData &state, int const coilNum);
+
+    std::string GetCoilChildCoilName(EnergyPlusData &state, int const coilNum);
 
+    int GetCoilChildCoilIndex(EnergyPlusData &state, int const coilType);  
+  
     bool VerifyHeatExchangerParent(EnergyPlusData &state,
                                    std::string const &HXType, // must match coil types in this module
                                    std::string const &HXName  // must match coil names for the coil type
     );
 
-} // namespace HVACHXAssistedCoolingCoil
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum);
+} // namespace HXAssistCoil
 
 struct HVACHXAssistedCoolingCoilData : BaseGlobalStruct
 {
@@ -242,7 +238,7 @@ struct HVACHXAssistedCoolingCoilData : BaseGlobalStruct
     Array1D<Real64> HXAssistedCoilOutletHumRat; // Outlet humidity ratio from this compound object
     bool GetCoilsInputFlag = true;              // Flag to allow input data to be retrieved from idf on first call to this subroutine
     Array1D_bool CheckEquipName;
-    Array1D<HVACHXAssistedCoolingCoil::HXAssistedCoilParameters> HXAssistedCoil;
+    Array1D<HXAssistCoil::HXAssistedCoilParameters> HXAssistedCoils;
     std::unordered_map<std::string, std::string> UniqueHXAssistedCoilNames;
     Real64 CoilOutputTempLast; // Exiting cooling coil temperature from last iteration
     int ErrCount = 0;
@@ -263,7 +259,7 @@ struct HVACHXAssistedCoolingCoilData : BaseGlobalStruct
         this->HXAssistedCoilOutletHumRat.clear();
         this->GetCoilsInputFlag = true;
         this->CheckEquipName.clear();
-        this->HXAssistedCoil.clear();
+        this->HXAssistedCoils.clear();
         this->UniqueHXAssistedCoilNames.clear();
         this->ErrCount = 0;
         this->ErrCount2 = 0;
diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc
index 319e0740bff..e096b6ccc7a 100644
--- a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc
+++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc
@@ -217,8 +217,6 @@ namespace HVACMultiSpeedHeatPump {
         Real64 PartLoadFrac; // compressor part load fraction
         Real64 SpeedRatio;   // compressor speed ratio
         bool UnitOn;         // TRUE if unit is on
-        int OutletNode;      // MSHP air outlet node
-        int InletNode;       // MSHP air inlet node
         Real64 AirMassFlow;  // air mass flow rate [kg/s]
         HVAC::FanOp fanOp;   // operating mode (fan cycling or continuous; DX coil always cycles)
         int ZoneNum;         // Controlled zone number
@@ -228,32 +226,32 @@ namespace HVACMultiSpeedHeatPump {
         Real64 SaveMassFlowRate;         // saved inlet air mass flow rate [kg/s]
 
         // zero the fan, DX coils, and supplemental electric heater electricity consumption
-        state.dataHVACGlobal->DXElecHeatingPower = 0.0;
+
+        // Why are these state variables?
+        state.dataHVACGlobal->DXElecHeatingPower = 0.0; 
         state.dataHVACGlobal->DXElecCoolingPower = 0.0;
         state.dataHVACMultiSpdHP->SaveCompressorPLR = 0.0;
         state.dataHVACGlobal->ElecHeatingCoilPower = 0.0;
         state.dataHVACGlobal->SuppHeatingCoilPower = 0.0;
         state.dataHVACGlobal->DefrostElecPower = 0.0;
 
-        auto &multiSpeedHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
 
         // initialize local variables
         UnitOn = true;
-        OutletNode = multiSpeedHeatPump.AirOutletNodeNum;
-        InletNode = multiSpeedHeatPump.AirInletNodeNum;
-        AirMassFlow = state.dataLoopNodes->Node(InletNode).MassFlowRate;
-        fanOp = multiSpeedHeatPump.fanOp;
-        ZoneNum = multiSpeedHeatPump.ControlZoneNum;
+        AirMassFlow = state.dataLoopNodes->Node(mshp.AirInletNode).MassFlowRate;
+        fanOp = mshp.fanOp;
+        ZoneNum = mshp.ControlZoneNum;
         compressorOp = HVAC::CompressorOp::On;
 
         // set the on/off flags
-        if (multiSpeedHeatPump.fanOp == HVAC::FanOp::Cycling) {
+        if (mshp.fanOp == HVAC::FanOp::Cycling) {
             // cycling unit only runs if there is a cooling or heating load.
             if (std::abs(QZnReq) < HVAC::SmallLoad || AirMassFlow < HVAC::SmallMassFlow ||
                 state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
                 UnitOn = false;
             }
-        } else if (multiSpeedHeatPump.fanOp == HVAC::FanOp::Continuous) {
+        } else if (mshp.fanOp == HVAC::FanOp::Continuous) {
             // continuous unit: fan runs if scheduled on; coil runs only if there is a cooling or heating load
             if (AirMassFlow < HVAC::SmallMassFlow) {
                 UnitOn = false;
@@ -262,11 +260,11 @@ namespace HVACMultiSpeedHeatPump {
 
         state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
 
-        SaveMassFlowRate = state.dataLoopNodes->Node(InletNode).MassFlowRate;
-        if (multiSpeedHeatPump.EMSOverrideCoilSpeedNumOn) {
-            Real64 SpeedVal = multiSpeedHeatPump.EMSOverrideCoilSpeedNumValue;
+        SaveMassFlowRate = state.dataLoopNodes->Node(mshp.AirInletNode).MassFlowRate;
+        if (mshp.EMSOverrideCoilSpeedNumOn) {
+            Real64 SpeedVal = mshp.EMSOverrideCoilSpeedNumValue;
 
-            if (!FirstHVACIteration && multiSpeedHeatPump.fanOp == HVAC::FanOp::Cycling && QZnReq < 0.0 &&
+            if (!FirstHVACIteration && mshp.fanOp == HVAC::FanOp::Cycling && QZnReq < 0.0 &&
                 state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive) {
                 compressorOp = HVAC::CompressorOp::Off;
                 ControlMSHPOutputEMS(state,
@@ -281,8 +279,8 @@ namespace HVACMultiSpeedHeatPump {
                                      PartLoadFrac,
                                      OnOffAirFlowRatio,
                                      SupHeaterLoad);
-                if (ceil(SpeedVal) == multiSpeedHeatPump.NumOfSpeedCooling && SpeedRatio == 1.0) {
-                    state.dataLoopNodes->Node(InletNode).MassFlowRate = SaveMassFlowRate;
+                if (ceil(SpeedVal) == mshp.NumOfSpeedCooling && SpeedRatio == 1.0) {
+                    state.dataLoopNodes->Node(mshp.AirInletNode).MassFlowRate = SaveMassFlowRate;
                     compressorOp = HVAC::CompressorOp::On;
                     ControlMSHPOutputEMS(state,
                                          MSHeatPumpNum,
@@ -312,7 +310,7 @@ namespace HVACMultiSpeedHeatPump {
                                      SupHeaterLoad);
             }
         } else {
-            if (!FirstHVACIteration && multiSpeedHeatPump.fanOp == HVAC::FanOp::Cycling && QZnReq < 0.0 &&
+            if (!FirstHVACIteration && mshp.fanOp == HVAC::FanOp::Cycling && QZnReq < 0.0 &&
                 state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive) {
                 // for cycling fan, cooling load, check whether furnace can meet load with compressor off
                 compressorOp = HVAC::CompressorOp::Off;
@@ -328,9 +326,9 @@ namespace HVACMultiSpeedHeatPump {
                                   PartLoadFrac,
                                   OnOffAirFlowRatio,
                                   SupHeaterLoad);
-                if (SpeedNum == multiSpeedHeatPump.NumOfSpeedCooling && SpeedRatio == 1.0) {
+                if (SpeedNum == mshp.NumOfSpeedCooling && SpeedRatio == 1.0) {
                     // compressor on (reset inlet air mass flow rate to starting value)
-                    state.dataLoopNodes->Node(InletNode).MassFlowRate = SaveMassFlowRate;
+                    state.dataLoopNodes->Node(mshp.AirInletNode).MassFlowRate = SaveMassFlowRate;
                     compressorOp = HVAC::CompressorOp::On;
                     ControlMSHPOutput(state,
                                       MSHeatPumpNum,
@@ -362,14 +360,14 @@ namespace HVACMultiSpeedHeatPump {
             }
         }
 
-        if (multiSpeedHeatPump.HeatCoilType != MultiSpeedHeatingCoil) {
+        if (mshp.heatCoilType != HVAC::CoilType::HeatingDXMultiSpeed) {
             state.dataHVACMultiSpdHP->SaveCompressorPLR = PartLoadFrac;
         } else {
             if (SpeedNum > 1) {
                 state.dataHVACMultiSpdHP->SaveCompressorPLR = 1.0;
             }
 
-            if (PartLoadFrac == 1.0 && state.dataHVACMultiSpdHP->SaveCompressorPLR < 1.0 && (!multiSpeedHeatPump.Staged)) {
+            if (PartLoadFrac == 1.0 && state.dataHVACMultiSpdHP->SaveCompressorPLR < 1.0 && (!mshp.Staged)) {
                 PartLoadFrac = state.dataHVACMultiSpdHP->SaveCompressorPLR;
             }
         }
@@ -387,59 +385,59 @@ namespace HVACMultiSpeedHeatPump {
                        SupHeaterLoad);
 
         // calculate delivered capacity
-        AirMassFlow = state.dataLoopNodes->Node(InletNode).MassFlowRate;
+        AirMassFlow = state.dataLoopNodes->Node(mshp.AirInletNode).MassFlowRate;
 
-        QTotUnitOut = AirMassFlow * (state.dataLoopNodes->Node(OutletNode).Enthalpy -
-                                     state.dataLoopNodes->Node(multiSpeedHeatPump.NodeNumOfControlledZone).Enthalpy);
+        QTotUnitOut = AirMassFlow * (state.dataLoopNodes->Node(mshp.AirOutletNode).Enthalpy -
+                                     state.dataLoopNodes->Node(mshp.NodeNumOfControlledZone).Enthalpy);
 
         // report variables
-        multiSpeedHeatPump.CompPartLoadRatio = state.dataHVACMultiSpdHP->SaveCompressorPLR;
-        if (multiSpeedHeatPump.fanOp == HVAC::FanOp::Cycling) {
+        mshp.CompPartLoadRatio = state.dataHVACMultiSpdHP->SaveCompressorPLR;
+        if (mshp.fanOp == HVAC::FanOp::Cycling) {
             if (SupHeaterLoad > 0.0) {
-                multiSpeedHeatPump.FanPartLoadRatio = 1.0;
+                mshp.FanPartLoadRatio = 1.0;
             } else {
                 if (SpeedNum < 2) {
-                    multiSpeedHeatPump.FanPartLoadRatio = PartLoadFrac;
+                    mshp.FanPartLoadRatio = PartLoadFrac;
                 } else {
-                    multiSpeedHeatPump.FanPartLoadRatio = 1.0;
+                    mshp.FanPartLoadRatio = 1.0;
                 }
             }
         } else {
             if (UnitOn) {
-                multiSpeedHeatPump.FanPartLoadRatio = 1.0;
+                mshp.FanPartLoadRatio = 1.0;
             } else {
                 if (SpeedNum < 2) {
-                    multiSpeedHeatPump.FanPartLoadRatio = PartLoadFrac;
+                    mshp.FanPartLoadRatio = PartLoadFrac;
                 } else {
-                    multiSpeedHeatPump.FanPartLoadRatio = 1.0;
+                    mshp.FanPartLoadRatio = 1.0;
                 }
             }
         }
 
-        if (multiSpeedHeatPump.HeatCoolMode == ModeOfOperation::HeatingMode) {
-            multiSpeedHeatPump.TotHeatEnergyRate = std::abs(max(0.0, QTotUnitOut));
-            multiSpeedHeatPump.SensHeatEnergyRate = std::abs(max(0.0, QSensUnitOut));
-            multiSpeedHeatPump.LatHeatEnergyRate = std::abs(max(0.0, (QTotUnitOut - QSensUnitOut)));
-            multiSpeedHeatPump.TotCoolEnergyRate = 0.0;
-            multiSpeedHeatPump.SensCoolEnergyRate = 0.0;
-            multiSpeedHeatPump.LatCoolEnergyRate = 0.0;
+        if (mshp.HeatCoolMode == ModeOfOperation::HeatingMode) {
+            mshp.TotHeatEnergyRate = std::abs(max(0.0, QTotUnitOut));
+            mshp.SensHeatEnergyRate = std::abs(max(0.0, QSensUnitOut));
+            mshp.LatHeatEnergyRate = std::abs(max(0.0, (QTotUnitOut - QSensUnitOut)));
+            mshp.TotCoolEnergyRate = 0.0;
+            mshp.SensCoolEnergyRate = 0.0;
+            mshp.LatCoolEnergyRate = 0.0;
         }
-        if (multiSpeedHeatPump.HeatCoolMode == ModeOfOperation::CoolingMode) {
-            multiSpeedHeatPump.TotCoolEnergyRate = std::abs(min(0.0, QTotUnitOut));
-            multiSpeedHeatPump.SensCoolEnergyRate = std::abs(min(0.0, QSensUnitOut));
-            multiSpeedHeatPump.LatCoolEnergyRate = std::abs(min(0.0, (QTotUnitOut - QSensUnitOut)));
-            multiSpeedHeatPump.TotHeatEnergyRate = 0.0;
-            multiSpeedHeatPump.SensHeatEnergyRate = 0.0;
-            multiSpeedHeatPump.LatHeatEnergyRate = 0.0;
+        if (mshp.HeatCoolMode == ModeOfOperation::CoolingMode) {
+            mshp.TotCoolEnergyRate = std::abs(min(0.0, QTotUnitOut));
+            mshp.SensCoolEnergyRate = std::abs(min(0.0, QSensUnitOut));
+            mshp.LatCoolEnergyRate = std::abs(min(0.0, (QTotUnitOut - QSensUnitOut)));
+            mshp.TotHeatEnergyRate = 0.0;
+            mshp.SensHeatEnergyRate = 0.0;
+            mshp.LatHeatEnergyRate = 0.0;
         }
 
-        multiSpeedHeatPump.AuxElecPower = multiSpeedHeatPump.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR +
-                                          multiSpeedHeatPump.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR);
+        mshp.AuxElecPower = mshp.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR +
+                                          mshp.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR);
         Real64 locFanElecPower = 0.0;
-        locFanElecPower = state.dataFans->fans(multiSpeedHeatPump.FanNum)->totalPower;
-        multiSpeedHeatPump.ElecPower = locFanElecPower + state.dataHVACGlobal->DXElecCoolingPower + state.dataHVACGlobal->DXElecHeatingPower +
+        locFanElecPower = state.dataFans->fans(mshp.FanNum)->totalPower;
+        mshp.ElecPower = locFanElecPower + state.dataHVACGlobal->DXElecCoolingPower + state.dataHVACGlobal->DXElecHeatingPower +
                                        state.dataHVACGlobal->ElecHeatingCoilPower + state.dataHVACGlobal->SuppHeatingCoilPower +
-                                       state.dataHVACGlobal->DefrostElecPower + multiSpeedHeatPump.AuxElecPower;
+                                       state.dataHVACGlobal->DefrostElecPower + mshp.AuxElecPower;
     }
 
     //******************************************************************************
@@ -484,9 +482,9 @@ namespace HVACMultiSpeedHeatPump {
         bool errFlag;
         Real64 SteamDensity; // density of steam at 100C
 
-        auto &MSHeatPump(state.dataHVACMultiSpdHP->MSHeatPump);
+        auto &s_node = state.dataLoopNodes;
 
-        if (MSHeatPump.allocated()) return;
+        if (state.dataHVACMultiSpdHP->MSHeatPump.allocated()) return;
 
         state.dataHVACMultiSpdHP->CurrentModuleObject =
             "AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed"; // Object type for getting and error messages
@@ -512,20 +510,14 @@ namespace HVACMultiSpeedHeatPump {
         }
 
         // ALLOCATE ARRAYS
-        MSHeatPump.allocate(state.dataHVACMultiSpdHP->NumMSHeatPumps);
+        state.dataHVACMultiSpdHP->MSHeatPump.allocate(state.dataHVACMultiSpdHP->NumMSHeatPumps);
         state.dataHVACMultiSpdHP->MSHeatPumpReport.allocate(state.dataHVACMultiSpdHP->NumMSHeatPumps);
         state.dataHVACMultiSpdHP->CheckEquipName.dimension(state.dataHVACMultiSpdHP->NumMSHeatPumps, true);
 
         // Load arrays with reformulated electric EIR chiller data
         for (int MSHPNum = 1; MSHPNum <= state.dataHVACMultiSpdHP->NumMSHeatPumps; ++MSHPNum) {
-            auto &thisMSHP = MSHeatPump(MSHPNum);
-            int HeatingCoilInletNode = 0;
-            int HeatingCoilOutletNode = 0;
-            int CoolingCoilInletNode = 0;
-            int CoolingCoilOutletNode = 0;
-            int SuppHeatCoilInletNode = 0;
-            int SuppHeatCoilOutletNode = 0;
-
+            auto &thisMSHP = state.dataHVACMultiSpdHP->MSHeatPump(MSHPNum);
+            
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      state.dataHVACMultiSpdHP->CurrentModuleObject,
                                                                      MSHPNum,
@@ -550,9 +542,7 @@ namespace HVACMultiSpeedHeatPump {
                 ErrorsFound = true;
             }
 
-            thisMSHP.AirInletNodeName = Alphas(3);
-            thisMSHP.AirOutletNodeName = Alphas(4);
-            thisMSHP.AirInletNodeNum = GetOnlySingleNode(state,
+            thisMSHP.AirInletNode = GetOnlySingleNode(state,
                                                          Alphas(3),
                                                          ErrorsFound,
                                                          DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed,
@@ -562,7 +552,7 @@ namespace HVACMultiSpeedHeatPump {
                                                          NodeInputManager::CompFluidStream::Primary,
                                                          DataLoopNode::ObjectIsParent);
 
-            thisMSHP.AirOutletNodeNum = GetOnlySingleNode(state,
+            thisMSHP.AirOutletNode = GetOnlySingleNode(state,
                                                           Alphas(4),
                                                           ErrorsFound,
                                                           DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed,
@@ -691,520 +681,195 @@ namespace HVACMultiSpeedHeatPump {
                 }
             }
 
-            if (Util::SameString(Alphas(10), "Coil:Heating:DX:MultiSpeed")) {
-                thisMSHP.HeatCoilType = MultiSpeedHeatingCoil;
-                thisMSHP.HeatCoilNum = state.dataInputProcessing->inputProcessor->getObjectItemNum(state, "Coil:Heating:DX:MultiSpeed", Alphas(11));
-                thisMSHP.DXHeatCoilName = Alphas(11);
-                if (thisMSHP.HeatCoilNum <= 0) {
-                    ShowSevereError(state, format("Configuration error in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, format("{} \"{}\" not found.", cAlphaFields(11), Alphas(11)));
-                    ShowContinueError(state, format("{} must be Coil:Heating:DX:MultiSpeed ", cAlphaFields(10)));
-                    ShowFatalError(state,
-                                   format("{}Errors found in getting {} input. Preceding condition(s) causes termination.",
-                                          RoutineName,
-                                          state.dataHVACMultiSpdHP->CurrentModuleObject));
-                    ErrorsFound = true;
-                }
-                LocalError = false;
-                DXCoils::GetDXCoilIndex(state, thisMSHP.DXHeatCoilName, thisMSHP.DXHeatCoilIndex, LocalError, "Coil:Heating:DX:MultiSpeed");
-                if (LocalError) {
-                    ShowSevereError(state, format("The index of {} is not found \"{}\"", cAlphaFields(11), Alphas(11)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                HeatingCoilInletNode = DXCoils::GetCoilInletNode(state, Alphas(10), Alphas(11), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The inlet node number of {} is not found \"{}\"", cAlphaFields(11), Alphas(11)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                HeatingCoilOutletNode = DXCoils::GetCoilOutletNode(state, Alphas(10), Alphas(11), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The outlet node number of {} is not found \"{}\"", cAlphaFields(11), Alphas(11)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
+            thisMSHP.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(10)));
+            thisMSHP.HeatCoilName = Alphas(11);
+
+            if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+                thisMSHP.HeatCoilNum = DXCoils::GetCoilIndex(state, thisMSHP.HeatCoilName);
+                if (thisMSHP.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), thisMSHP.HeatCoilName);
                     ErrorsFound = true;
-                    LocalError = false;
-                }
-                thisMSHP.MinOATCompressorHeating = DXCoils::GetMinOATCompressor(state, thisMSHP.DXHeatCoilIndex, LocalError);
-                if (LocalError) {
-                    ShowContinueError(state,
-                                      format("...for heating coil. Occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    LocalError = false;
-                }
-                BranchNodeConnections::SetUpCompSets(state,
-                                                     state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                                     thisMSHP.Name,
-                                                     "Coil:Heating:DX:MultiSpeed",
-                                                     thisMSHP.DXHeatCoilName,
-                                                     "UNDEFINED",
-                                                     "UNDEFINED");
-            } else if (Util::SameString(Alphas(10), "Coil:Heating:Electric:MultiStage") ||
-                       Util::SameString(Alphas(10), "Coil:Heating:Gas:MultiStage")) {
-
-                if (Util::SameString(Alphas(10), "Coil:Heating:Electric:MultiStage")) {
-                    thisMSHP.HeatCoilType = HVAC::Coil_HeatingElectric_MultiStage;
-                    thisMSHP.HeatCoilNum =
-                        state.dataInputProcessing->inputProcessor->getObjectItemNum(state, "Coil:Heating:Electric:MultiStage", Alphas(11));
-                    if (thisMSHP.HeatCoilNum <= 0) {
-                        ShowSevereError(state, format("Configuration error in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(state, format("{} \"{}\" not found.", cAlphaFields(11), Alphas(11)));
-                        ShowContinueError(state, format("{} must be Coil:Heating:Electric:MultiStage ", cAlphaFields(10)));
-                        ShowFatalError(state,
-                                       format("{}Errors found in getting {} input. Preceding condition(s) causes termination.",
-                                              RoutineName,
-                                              state.dataHVACMultiSpdHP->CurrentModuleObject));
-                        ErrorsFound = true;
-                    }
                 } else {
-                    thisMSHP.HeatCoilType = HVAC::Coil_HeatingGas_MultiStage;
-                    thisMSHP.HeatCoilNum =
-                        state.dataInputProcessing->inputProcessor->getObjectItemNum(state, "Coil:Heating:Gas:MultiStage", Alphas(11));
-                    if (thisMSHP.HeatCoilNum <= 0) {
-                        ShowSevereError(state, format("Configuration error in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                        ShowContinueError(state, format("{} \"{}\" not found.", cAlphaFields(11), Alphas(11)));
-                        ShowContinueError(state, format("{} must be Coil:Heating:Gas:MultiStage ", cAlphaFields(10)));
-                        ShowFatalError(state,
-                                       format("{}Errors found in getting {} input. Preceding condition(s) causes termination.",
-                                              RoutineName,
-                                              state.dataHVACMultiSpdHP->CurrentModuleObject));
-                        ErrorsFound = true;
-                    }
-                }
-                thisMSHP.HeatCoilName = Alphas(11);
-                LocalError = false;
-                if (Util::SameString(Alphas(10), "Coil:Heating:Electric:MultiStage")) {
-                    HeatingCoils::GetCoilIndex(state, thisMSHP.HeatCoilName, thisMSHP.HeatCoilIndex, LocalError);
-                } else {
-                    HeatingCoils::GetCoilIndex(state, thisMSHP.HeatCoilName, thisMSHP.HeatCoilIndex, LocalError);
-                }
-                if (LocalError) {
-                    ShowSevereError(state, format("The index of {} is not found \"{}\"", cAlphaFields(11), Alphas(11)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                HeatingCoilInletNode = HeatingCoils::GetCoilInletNode(state, Alphas(10), Alphas(11), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The inlet node number of {} is not found \"{}\"", cAlphaFields(11), Alphas(11)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                HeatingCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, Alphas(10), Alphas(11), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The outlet node number of {} is not found \"{}\"", cAlphaFields(11), Alphas(11)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                if (Util::SameString(Alphas(10), "Coil:Heating:Electric:MultiStage")) {
+                    thisMSHP.HeatCoilAirInletNode = DXCoils::GetCoilAirInletNode(state, thisMSHP.HeatCoilNum); 
+                    thisMSHP.HeatCoilAirOutletNode = DXCoils::GetCoilAirOutletNode(state, thisMSHP.HeatCoilNum);
+
+                    thisMSHP.MinOATCompressorHeating = DXCoils::GetCoilMinOATCompressor(state, thisMSHP.HeatCoilNum);
                     BranchNodeConnections::SetUpCompSets(state,
                                                          state.dataHVACMultiSpdHP->CurrentModuleObject,
                                                          thisMSHP.Name,
-                                                         "Coil:Heating:Electric:MultiStage",
+                                                         "Coil:Heating:DX:MultiSpeed",
                                                          thisMSHP.HeatCoilName,
                                                          "UNDEFINED",
                                                          "UNDEFINED");
+                }
+                
+            } else if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingElectricMultiStage || 
+                       thisMSHP.heatCoilType == HVAC::CoilType::HeatingGasMultiStage) { 
+
+                thisMSHP.HeatCoilNum = HeatingCoils::GetCoilIndex(state, thisMSHP.HeatCoilName);
+                if (thisMSHP.HeatCoilNum == 0) { 
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), thisMSHP.HeatCoilName);
+                    ErrorsFound = true;
                 } else {
+                    thisMSHP.HeatCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, thisMSHP.HeatCoilNum);
+                    thisMSHP.HeatCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, thisMSHP.HeatCoilNum);
+
                     BranchNodeConnections::SetUpCompSets(state,
                                                          state.dataHVACMultiSpdHP->CurrentModuleObject,
                                                          thisMSHP.Name,
-                                                         "Coil:Heating:Gas:MultiStage",
+                                                         HVAC::coilTypeNames[(int)thisMSHP.heatCoilType], 
                                                          thisMSHP.HeatCoilName,
                                                          "UNDEFINED",
                                                          "UNDEFINED");
                 }
-            } else if (Util::SameString(Alphas(10), "Coil:Heating:Water")) {
-                thisMSHP.HeatCoilType = HVAC::Coil_HeatingWater;
-                ValidateComponent(state, Alphas(10), Alphas(11), IsNotOK, state.dataHVACMultiSpdHP->CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
+                
+            } else if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingWater) {
+                // Get the Heating Coil water Inlet or control Node number
+                thisMSHP.HeatCoilNum = WaterCoils::GetCoilIndex(state, thisMSHP.HeatCoilName);
+                if (thisMSHP.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), thisMSHP.HeatCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    thisMSHP.HeatCoilName = Alphas(11);
-                    // Get the Heating Coil water Inlet or control Node number
-                    errFlag = false;
-                    thisMSHP.CoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", thisMSHP.HeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil hot water max volume flow rate
-                    errFlag = false;
-                    thisMSHP.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisMSHP.HeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the supplemental Heating Coil Inlet Node
-                    errFlag = false;
-                    HeatingCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", thisMSHP.HeatCoilName, errFlag);
-                    thisMSHP.CoilAirInletNode = HeatingCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
+                } else {
+                    thisMSHP.HeatCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, thisMSHP.HeatCoilNum);
+                    thisMSHP.HeatCoilMaxFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, thisMSHP.HeatCoilNum);
+                    thisMSHP.HeatCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, thisMSHP.HeatCoilNum);
+                    thisMSHP.HeatCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, thisMSHP.HeatCoilNum);
 
-                    // Get the supplemental Heating Coil Outlet Node
-                    errFlag = false;
-                    HeatingCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", thisMSHP.HeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
                     BranchNodeConnections::SetUpCompSets(state,
                                                          state.dataHVACMultiSpdHP->CurrentModuleObject,
                                                          thisMSHP.Name,
-                                                         "Coil:Heating:Water",
+                                                         HVAC::coilTypeNames[(int)thisMSHP.heatCoilType],
                                                          thisMSHP.HeatCoilName,
-                                                         state.dataLoopNodes->NodeID(HeatingCoilInletNode),
-                                                         state.dataLoopNodes->NodeID(HeatingCoilOutletNode));
-                }
-            } else if (Util::SameString(Alphas(10), "Coil:Heating:Steam")) {
-                thisMSHP.HeatCoilType = HVAC::Coil_HeatingSteam;
-                ValidateComponent(state, Alphas(10), Alphas(11), IsNotOK, state.dataHVACMultiSpdHP->CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
+                                                         s_node->NodeID(thisMSHP.HeatCoilAirInletNode),
+                                                         s_node->NodeID(thisMSHP.HeatCoilAirOutletNode));
+                }
+                
+            } else if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                thisMSHP.HeatCoilNum = SteamCoils::GetCoilIndex(state, thisMSHP.HeatCoilName);
+                if (thisMSHP.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(11), thisMSHP.HeatCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    thisMSHP.HeatCoilName = Alphas(11);
-                    errFlag = false;
-                    thisMSHP.HeatCoilNum = SteamCoils::GetSteamCoilIndex(state, Alphas(10), thisMSHP.HeatCoilName, errFlag);
-                    if (thisMSHP.HeatCoilNum == 0) {
-                        ShowSevereError(
-                            state,
-                            format("{} illegal {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, cAlphaFields(10), thisMSHP.HeatCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the supplemental Heating Coil steam inlet node number
-                    errFlag = false;
-                    thisMSHP.CoilControlNode = SteamCoils::GetCoilAirOutletNode(state, "Coil:Heating:Steam", thisMSHP.HeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the supplemental Heating Coil steam max volume flow rate
-                    thisMSHP.MaxCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.HeatCoilNum, errFlag);
-                    if (thisMSHP.MaxCoilFluidFlow > 0.0) {
-                        SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, routineName);
-                        thisMSHP.MaxCoilFluidFlow *= SteamDensity;
+                } else {
+                    thisMSHP.HeatCoilControlNode = SteamCoils::GetCoilAirOutletNode(state, thisMSHP.HeatCoilNum);
+                    thisMSHP.HeatCoilMaxFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.HeatCoilNum);
+                    if (thisMSHP.HeatCoilMaxFluidFlow > 0.0) {
+                        thisMSHP.HeatCoilMaxFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                     }
 
                     // Get the supplemental Heating Coil Inlet Node
-                    errFlag = false;
-                    HeatingCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisMSHP.HeatCoilNum, thisMSHP.HeatCoilName, errFlag);
-                    thisMSHP.CoilAirInletNode = HeatingCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the supplemental Heating Coil Outlet Node
-                    errFlag = false;
-                    HeatingCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisMSHP.HeatCoilNum, thisMSHP.HeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
+                    thisMSHP.HeatCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, thisMSHP.HeatCoilNum);
+                    thisMSHP.HeatCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisMSHP.HeatCoilNum);
                     BranchNodeConnections::SetUpCompSets(state,
                                                          state.dataHVACMultiSpdHP->CurrentModuleObject,
                                                          thisMSHP.Name,
-                                                         "Coil:Heating:Steam",
+                                                         HVAC::coilTypeNames[(int)thisMSHP.heatCoilType],
                                                          thisMSHP.HeatCoilName,
-                                                         state.dataLoopNodes->NodeID(HeatingCoilInletNode),
-                                                         state.dataLoopNodes->NodeID(HeatingCoilOutletNode));
+                                                         s_node->NodeID(thisMSHP.HeatCoilAirInletNode),
+                                                         s_node->NodeID(thisMSHP.HeatCoilAirOutletNode));
                 }
             } else {
-                ShowSevereError(state,
-                                format("The allowed {} are Coil:Heating:DX:MultiSpeed, Coil:Heating:Electric:MultiStage, and "
-                                       "Coil:Heating:Gas:MultiStage  in {} \"{}\"",
-                                       cAlphaFields(10),
-                                       state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                       Alphas(1)));
-                ShowContinueError(state, format("The entered {} = \"{}\".", cAlphaFields(10), Alphas(10)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(10), Alphas(10));
                 ErrorsFound = true;
             }
 
             // thisMSHP.MinOATCompressor = Numbers(1); // deprecated, now uses coil MinOAT inputs
 
-            if (Util::SameString(Alphas(12), "Coil:Cooling:DX:MultiSpeed")) {
-                thisMSHP.CoolCoilType = MultiSpeedCoolingCoil;
-                thisMSHP.DXCoolCoilName = Alphas(13);
-                if (state.dataInputProcessing->inputProcessor->getObjectItemNum(state, "Coil:Cooling:DX:MultiSpeed", Alphas(13)) <= 0) {
-                    ShowSevereError(state, format("Configuration error in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, format("{} \"{}\" not found.", cAlphaFields(13), Alphas(13)));
-                    ShowContinueError(state, format("{} must be Coil:Cooling:DX:MultiSpeed ", cAlphaFields(12)));
-                    ShowFatalError(state,
-                                   format("{}Errors found in getting {} input. Preceding condition(s) causes termination.",
-                                          RoutineName,
-                                          state.dataHVACMultiSpdHP->CurrentModuleObject));
-                    ErrorsFound = true;
-                }
-                LocalError = false;
-                DXCoils::GetDXCoilIndex(state, thisMSHP.DXCoolCoilName, thisMSHP.DXCoolCoilIndex, LocalError, "Coil:Cooling:DX:MultiSpeed");
-                if (LocalError) {
-                    ShowSevereError(state, format("The index of {} is not found \"{}\"", cAlphaFields(13), Alphas(13)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                CoolingCoilInletNode = DXCoils::GetCoilInletNode(state, Alphas(12), Alphas(13), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The inlet node number of {} is not found \"{}\"", cAlphaFields(13), Alphas(13)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                CoolingCoilOutletNode = DXCoils::GetCoilOutletNode(state, Alphas(12), Alphas(13), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The outlet node number of {} is not found \"{}\"", cAlphaFields(13), Alphas(13)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
+            thisMSHP.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(12)));
+            thisMSHP.CoolCoilName = Alphas(13);
+
+            if (thisMSHP.coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
+              
+                thisMSHP.CoolCoilNum = DXCoils::GetCoilIndex(state, thisMSHP.CoolCoilName);
+                if (thisMSHP.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(13), thisMSHP.CoolCoilName);
                     ErrorsFound = true;
-                    LocalError = false;
-                }
-                thisMSHP.MinOATCompressorCooling = DXCoils::GetMinOATCompressor(state, thisMSHP.DXCoolCoilIndex, LocalError);
-                if (LocalError) {
-                    ShowContinueError(state,
-                                      format("...for cooling coil. Occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    LocalError = false;
+                } else {
+                    thisMSHP.CoolCoilAirInletNode = DXCoils::GetCoilAirInletNode(state, thisMSHP.CoolCoilNum);
+                    thisMSHP.CoolCoilAirOutletNode = DXCoils::GetCoilAirOutletNode(state, thisMSHP.CoolCoilNum);
+                    thisMSHP.MinOATCompressorCooling = DXCoils::GetCoilMinOATCompressor(state, thisMSHP.CoolCoilNum);
+            
+                    BranchNodeConnections::SetUpCompSets(state,
+                                                         state.dataHVACMultiSpdHP->CurrentModuleObject,
+                                                         thisMSHP.Name,
+                                                         HVAC::coilTypeNames[(int)thisMSHP.coolCoilType],
+                                                         thisMSHP.CoolCoilName,
+                                                         "UNDEFINED",
+                                                         "UNDEFINED");
                 }
             } else {
-                ShowSevereError(state,
-                                format("The allowed {} is Coil:Cooling:DX:MultiSpeed in {} \"{}\"",
-                                       cAlphaFields(12),
-                                       state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                       Alphas(1)));
-                ShowContinueError(state, format("The entered {} = \"{}\".", cAlphaFields(12), Alphas(12)));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(12), Alphas(12));
                 ErrorsFound = true;
             }
-            BranchNodeConnections::SetUpCompSets(state,
-                                                 state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                                 thisMSHP.Name,
-                                                 "Coil:Cooling:DX:MultiSpeed",
-                                                 thisMSHP.DXCoolCoilName,
-                                                 "UNDEFINED",
-                                                 "UNDEFINED");
 
             // Get supplemental heating coil data
+            thisMSHP.suppHeatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(14)));
             thisMSHP.SuppHeatCoilName = Alphas(15);
-            if (Util::SameString(Alphas(14), "Coil:Heating:Fuel")) {
-                thisMSHP.SuppHeatCoilType = SuppHeatingCoilGas;
-                errFlag = false;
-                thisMSHP.SuppHeatCoilNum = HeatingCoils::GetHeatingCoilIndex(state, "Coil:Heating:Fuel", Alphas(15), errFlag);
-                if (thisMSHP.SuppHeatCoilNum <= 0 || errFlag) {
-                    ShowContinueError(state, format("Configuration error in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, format("{} of type Coil:Heating:Fuel \"{}\" not found.", cAlphaFields(15), Alphas(15)));
+            
+            if (thisMSHP.suppHeatCoilType == HVAC::CoilType::HeatingElectric ||
+                thisMSHP.suppHeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel) {
+              
+                thisMSHP.SuppHeatCoilNum = HeatingCoils::GetCoilIndex(state, thisMSHP.SuppHeatCoilName);
+                if (thisMSHP.SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(15), thisMSHP.SuppHeatCoilName);
                     ErrorsFound = true;
+                } else {
+                    thisMSHP.SuppHeatCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, thisMSHP.SuppHeatCoilNum);
+                    thisMSHP.SuppHeatCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, thisMSHP.SuppHeatCoilNum);
+                    thisMSHP.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, thisMSHP.SuppHeatCoilNum);
+                    BranchNodeConnections::SetUpCompSets(state,
+                                                         state.dataHVACMultiSpdHP->CurrentModuleObject,
+                                                         thisMSHP.Name,
+                                                         HVAC::coilTypeNames[(int)thisMSHP.suppHeatCoilType],
+                                                         thisMSHP.SuppHeatCoilName,
+                                                         "UNDEFINED",
+                                                         "UNDEFINED");
                 }
-
-                // Get the Supplemental Heating Coil Node Numbers
-                LocalError = false;
-                SuppHeatCoilInletNode = HeatingCoils::GetCoilInletNode(state, Alphas(14), Alphas(15), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The inlet node number of {} is not found \"{}\"", cAlphaFields(15), Alphas(15)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                SuppHeatCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, Alphas(14), Alphas(15), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The outlet node number of {} is not found \"{}\"", cAlphaFields(15), Alphas(15)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-
-                // Get supplemental heating coil capacity to see if it is autosize
-                thisMSHP.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, Alphas(14), Alphas(15), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The capacity {} is not found \"{}\"", cAlphaFields(15), Alphas(15)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                BranchNodeConnections::SetUpCompSets(state,
-                                                     state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                                     thisMSHP.Name,
-                                                     "Coil:Heating:Fuel",
-                                                     thisMSHP.SuppHeatCoilName,
-                                                     "UNDEFINED",
-                                                     "UNDEFINED");
-            }
-            if (Util::SameString(Alphas(14), "Coil:Heating:Electric")) {
-                thisMSHP.SuppHeatCoilType = SuppHeatingCoilElec;
-                errFlag = false;
-                thisMSHP.SuppHeatCoilNum = HeatingCoils::GetHeatingCoilIndex(state, "Coil:Heating:Electric", Alphas(15), errFlag);
-                if (thisMSHP.SuppHeatCoilNum <= 0 || errFlag) {
-                    ShowContinueError(state, format("Configuration error in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state, format("{} of type Coil:Heating:Electric \"{}\" not found.", cAlphaFields(15), Alphas(15)));
-                    ErrorsFound = true;
-                }
-
-                // Get the Supplemental Heating Coil Node Numbers
-                LocalError = false;
-                SuppHeatCoilInletNode = HeatingCoils::GetCoilInletNode(state, Alphas(14), Alphas(15), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The inlet node number of {} is not found \"{}\"", cAlphaFields(15), Alphas(15)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-                SuppHeatCoilOutletNode = HeatingCoils::GetCoilOutletNode(state, Alphas(14), Alphas(15), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The outlet node number of {} is not found \"{}\"", cAlphaFields(15), Alphas(15)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-
-                // Get supplemental heating coil capacity to see if it is autosize
-                thisMSHP.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, Alphas(14), Alphas(15), LocalError);
-                if (LocalError) {
-                    ShowSevereError(state, format("The capacity {} is not found \"{}\"", cAlphaFields(15), Alphas(15)));
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
-                    ErrorsFound = true;
-                    LocalError = false;
-                }
-
-                BranchNodeConnections::SetUpCompSets(state,
-                                                     state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                                     thisMSHP.Name,
-                                                     "Coil:Heating:Electric",
-                                                     thisMSHP.SuppHeatCoilName,
-                                                     "UNDEFINED",
-                                                     "UNDEFINED");
-            }
-
-            if (Util::SameString(Alphas(14), "Coil:Heating:Water")) {
-                thisMSHP.SuppHeatCoilType = HVAC::Coil_HeatingWater;
-                ValidateComponent(state, Alphas(14), thisMSHP.SuppHeatCoilName, IsNotOK, state.dataHVACMultiSpdHP->CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1)));
+                
+            } else if (thisMSHP.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
+                thisMSHP.SuppHeatCoilNum = WaterCoils::GetCoilIndex(state, thisMSHP.SuppHeatCoilName);
+                if (thisMSHP.SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(15), thisMSHP.SuppHeatCoilName);
                     ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    // Get the Heating Coil water Inlet or control Node number
-                    errFlag = false;
-                    thisMSHP.SuppCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", thisMSHP.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the ReHeat Coil hot water max volume flow rate
-                    errFlag = false;
-                    thisMSHP.MaxSuppCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisMSHP.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Supplemental Heating Coil Inlet Node
-                    errFlag = false;
-                    SuppHeatCoilInletNode = WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", thisMSHP.SuppHeatCoilName, errFlag);
-                    thisMSHP.SuppCoilAirInletNode = SuppHeatCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Supplemental Heating Coil Outlet Node
-                    errFlag = false;
-                    SuppHeatCoilOutletNode = WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", thisMSHP.SuppHeatCoilName, errFlag);
-                    thisMSHP.SuppCoilAirOutletNode = SuppHeatCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
+                } else {
+                    thisMSHP.SuppHeatCoilControlNode = WaterCoils::GetCoilWaterInletNode(state, thisMSHP.SuppHeatCoilNum);
+                    thisMSHP.SuppHeatCoilMaxFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, thisMSHP.SuppHeatCoilNum);
+                    thisMSHP.SuppHeatCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, thisMSHP.SuppHeatCoilNum);
+                    thisMSHP.SuppHeatCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, thisMSHP.SuppHeatCoilNum);
                     BranchNodeConnections::SetUpCompSets(state,
                                                          state.dataHVACMultiSpdHP->CurrentModuleObject,
                                                          thisMSHP.Name,
                                                          "Coil:Heating:Water",
                                                          thisMSHP.SuppHeatCoilName,
-                                                         state.dataLoopNodes->NodeID(SuppHeatCoilInletNode),
-                                                         state.dataLoopNodes->NodeID(SuppHeatCoilOutletNode));
+                                                         s_node->NodeID(thisMSHP.SuppHeatCoilAirInletNode),
+                                                         s_node->NodeID(thisMSHP.SuppHeatCoilAirOutletNode));
                 }
-            }
-            if (Util::SameString(Alphas(14), "Coil:Heating:Steam")) {
-                thisMSHP.SuppHeatCoilType = HVAC::Coil_HeatingSteam;
-                ValidateComponent(state, Alphas(14), thisMSHP.SuppHeatCoilName, IsNotOK, state.dataHVACMultiSpdHP->CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("...occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                    ErrorsFound = true;
-                } else { // mine data from heating coil object
 
-                    errFlag = false;
-                    thisMSHP.SuppHeatCoilNum = SteamCoils::GetSteamCoilIndex(state, Alphas(14), thisMSHP.SuppHeatCoilName, errFlag);
-                    if (thisMSHP.SuppHeatCoilNum == 0) {
-                        ShowSevereError(
-                            state,
-                            format("{} illegal {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, cAlphaFields(14), thisMSHP.SuppHeatCoilName));
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Supplemental Heating Coil steam inlet node number
-                    errFlag = false;
-                    thisMSHP.SuppCoilControlNode = SteamCoils::GetCoilAirOutletNode(state, "Coil:Heating:Steam", thisMSHP.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Supplemental Heating Coil steam max volume flow rate
-                    thisMSHP.MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.SuppHeatCoilNum, errFlag);
-                    if (thisMSHP.MaxSuppCoilFluidFlow > 0.0) {
-                        SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, routineName);
-                        thisMSHP.MaxSuppCoilFluidFlow *= SteamDensity;
-                    }
-
-                    // Get the Supplemental Heating Coil Inlet Node
-                    errFlag = false;
-                    SuppHeatCoilInletNode = SteamCoils::GetCoilAirInletNode(state, thisMSHP.SuppHeatCoilNum, thisMSHP.SuppHeatCoilName, errFlag);
-                    thisMSHP.SuppCoilAirInletNode = SuppHeatCoilInletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
-                    }
-
-                    // Get the Supplemental Heating Coil Outlet Node
-                    errFlag = false;
-                    SuppHeatCoilOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisMSHP.SuppHeatCoilNum, thisMSHP.SuppHeatCoilName, errFlag);
-                    thisMSHP.SuppCoilAirOutletNode = SuppHeatCoilOutletNode;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
-                        ErrorsFound = true;
+            } else if (thisMSHP.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
+                thisMSHP.SuppHeatCoilNum = SteamCoils::GetCoilIndex(state, thisMSHP.SuppHeatCoilName);
+                if (thisMSHP.SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(15), thisMSHP.SuppHeatCoilName);
+                    ErrorsFound = true;
+                } else {
+                    // This is the control node?  Everywhere else the control node is a fluid node.
+                    thisMSHP.SuppHeatCoilControlNode = SteamCoils::GetCoilAirOutletNode(state, thisMSHP.SuppHeatCoilNum);
+                    thisMSHP.SuppHeatCoilMaxFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisMSHP.SuppHeatCoilNum);
+                    if (thisMSHP.SuppHeatCoilMaxFluidFlow > 0.0) {
+                        thisMSHP.SuppHeatCoilMaxFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                     }
 
+                    thisMSHP.SuppHeatCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, thisMSHP.SuppHeatCoilNum);
+                    thisMSHP.SuppHeatCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisMSHP.SuppHeatCoilNum);
                     BranchNodeConnections::SetUpCompSets(state,
                                                          state.dataHVACMultiSpdHP->CurrentModuleObject,
                                                          thisMSHP.Name,
-                                                         "Coil:Heating:Steam",
+                                                         HVAC::coilTypeNames[(int)thisMSHP.suppHeatCoilType],
                                                          thisMSHP.SuppHeatCoilName,
-                                                         state.dataLoopNodes->NodeID(SuppHeatCoilInletNode),
-                                                         state.dataLoopNodes->NodeID(SuppHeatCoilOutletNode));
+                                                         s_node->NodeID(thisMSHP.SuppHeatCoilAirInletNode),
+                                                         s_node->NodeID(thisMSHP.SuppHeatCoilAirOutletNode));
                 }
-            }
-
-            if (thisMSHP.SuppHeatCoilType == 0) {
-                ShowSevereError(state,
-                                format("{}, \"{}\", {} is not allowed = {}",
-                                       state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                       thisMSHP.Name,
-                                       cAlphaFields(14),
-                                       Alphas(14)));
-                ShowContinueError(state, "Valid choices are Coil:Heating:Fuel,Coil:Heating:Electric,Coil:Heating:Steam,or Coil:Heating:Water");
+                
+            } else {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(14), Alphas(14));
                 ErrorsFound = true;
             }
 
@@ -1218,7 +883,7 @@ namespace HVACMultiSpeedHeatPump {
                 ErrorsFound = true;
             }
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, thisMSHP.DXHeatCoilName, thisMSHP.SuppMaxOATemp);
+                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, thisMSHP.HeatCoilName, thisMSHP.SuppMaxOATemp);
 
             thisMSHP.AuxOnCyclePower = Numbers(4);
             thisMSHP.AuxOffCyclePower = Numbers(5);
@@ -1244,7 +909,7 @@ namespace HVACMultiSpeedHeatPump {
             if (thisMSHP.DesignHeatRecFlowRate > 0.0) {
                 thisMSHP.HeatRecActive = true;
                 thisMSHP.DesignHeatRecMassFlowRate = Psychrometrics::RhoH2O(Constant::HWInitConvTemp) * thisMSHP.DesignHeatRecFlowRate;
-                thisMSHP.HeatRecInletNodeNum = GetOnlySingleNode(state,
+                thisMSHP.HeatRecFluidInletNode = GetOnlySingleNode(state,
                                                                  Alphas(16),
                                                                  ErrorsFound,
                                                                  DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed,
@@ -1253,12 +918,12 @@ namespace HVACMultiSpeedHeatPump {
                                                                  DataLoopNode::ConnectionType::Inlet,
                                                                  NodeInputManager::CompFluidStream::Tertiary,
                                                                  DataLoopNode::ObjectIsNotParent);
-                if (thisMSHP.HeatRecInletNodeNum == 0) {
+                if (thisMSHP.HeatRecFluidInletNode == 0) {
                     ShowSevereError(
                         state, format("{}, \"{}\", Missing {}.", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name, cAlphaFields(16)));
                     ErrorsFound = true;
                 }
-                thisMSHP.HeatRecOutletNodeNum = GetOnlySingleNode(state,
+                thisMSHP.HeatRecFluidOutletNode = GetOnlySingleNode(state,
                                                                   Alphas(17),
                                                                   ErrorsFound,
                                                                   DataLoopNode::ConnectionObjectType::AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed,
@@ -1267,22 +932,22 @@ namespace HVACMultiSpeedHeatPump {
                                                                   DataLoopNode::ConnectionType::Outlet,
                                                                   NodeInputManager::CompFluidStream::Tertiary,
                                                                   DataLoopNode::ObjectIsNotParent);
-                if (thisMSHP.HeatRecOutletNodeNum == 0) {
+                if (thisMSHP.HeatRecFluidOutletNode == 0) {
                     ShowSevereError(
                         state, format("{}, \"{}\", Missing {}.", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name, cAlphaFields(17)));
                     ErrorsFound = true;
                 }
                 BranchNodeConnections::TestCompSet(
                     state, state.dataHVACMultiSpdHP->CurrentModuleObject, Alphas(1), Alphas(16), Alphas(17), "MSHP Heat Recovery Nodes");
-                DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, thisMSHP.DXCoolCoilIndex);
-                if (thisMSHP.DXHeatCoilIndex > 0) {
-                    DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, thisMSHP.DXHeatCoilIndex);
+                DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, thisMSHP.CoolCoilNum);
+                if (thisMSHP.HeatCoilNum > 0) {
+                    DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, thisMSHP.HeatCoilNum);
                 }
             } else {
                 thisMSHP.HeatRecActive = false;
                 thisMSHP.DesignHeatRecMassFlowRate = 0.0;
-                thisMSHP.HeatRecInletNodeNum = 0;
-                thisMSHP.HeatRecOutletNodeNum = 0;
+                thisMSHP.HeatRecFluidInletNode = 0;
+                thisMSHP.HeatRecFluidOutletNode = 0;
                 if (!lAlphaBlanks(16) || !lAlphaBlanks(17)) {
                     ShowWarningError(state,
                                      format("Since {} = 0.0, heat recovery is inactive for {} = {}",
@@ -1331,7 +996,7 @@ namespace HVACMultiSpeedHeatPump {
 
             thisMSHP.NumOfSpeedHeating = Numbers(9);
             if (thisMSHP.NumOfSpeedHeating < 2 || thisMSHP.NumOfSpeedHeating > 4) {
-                if (thisMSHP.HeatCoilType == MultiSpeedHeatingCoil) {
+                if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                     ShowSevereError(state,
                                     format("{}, The maximum {} is 4, and the minimum number is 2",
                                            state.dataHVACMultiSpdHP->CurrentModuleObject,
@@ -1358,7 +1023,7 @@ namespace HVACMultiSpeedHeatPump {
                 thisMSHP.HeatingSpeedRatio = 1.0;
                 for (i = 1; i <= thisMSHP.NumOfSpeedHeating; ++i) {
                     thisMSHP.HeatVolumeFlowRate(i) = Numbers(10 + i);
-                    if (thisMSHP.HeatCoilType == MultiSpeedHeatingCoil) {
+                    if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                         if (thisMSHP.HeatVolumeFlowRate(i) <= 0.0 && thisMSHP.HeatVolumeFlowRate(i) != DataSizing::AutoSize) {
                             ShowSevereError(state,
                                             format("{}, \"{}\", {} must be greater than zero.",
@@ -1394,7 +1059,7 @@ namespace HVACMultiSpeedHeatPump {
             if (state.dataGlobal->DoCoilDirectSolutions) {
                 int MaxNumber = std::max(thisMSHP.NumOfSpeedCooling, thisMSHP.NumOfSpeedHeating);
                 thisMSHP.FullOutput.allocate(MaxNumber);
-                DXCoils::DisableLatentDegradation(state, thisMSHP.DXCoolCoilIndex);
+                DXCoils::DisableLatentDegradation(state, thisMSHP.CoolCoilNum);
             }
             // Generate a dynamic array for cooling
             if (thisMSHP.NumOfSpeedCooling > 0) {
@@ -1437,110 +1102,112 @@ namespace HVACMultiSpeedHeatPump {
 
             // Check node integrity
             if (thisMSHP.fanPlace == HVAC::FanPlace::BlowThru) {
-                if (thisMSHP.FanInletNode != thisMSHP.AirInletNodeNum) {
+                if (thisMSHP.FanInletNode != thisMSHP.AirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(
                         state, format("When a blow through fan is specified, the fan inlet node name must be the same as the {}", cAlphaFields(3)));
-                    ShowContinueError(state, format("...Fan inlet node name           = {}", state.dataLoopNodes->NodeID(thisMSHP.FanInletNode)));
-                    ShowContinueError(state, format("...{} = {}", cAlphaFields(3), state.dataLoopNodes->NodeID(thisMSHP.AirInletNodeNum)));
+                    ShowContinueError(state, format("...Fan inlet node name           = {}", s_node->NodeID(thisMSHP.FanInletNode)));
+                    ShowContinueError(state, format("...{} = {}", cAlphaFields(3), s_node->NodeID(thisMSHP.AirInletNode)));
                     ErrorsFound = true;
                 }
-                if (thisMSHP.FanOutletNode != CoolingCoilInletNode) {
+                if (thisMSHP.FanOutletNode != thisMSHP.CoolCoilAirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(
                         state,
                         "When a blow through fan is specified, the fan outlet node name must be the same as the cooling coil inlet node name.");
-                    ShowContinueError(state, format("...Fan outlet node name         = {}", state.dataLoopNodes->NodeID(thisMSHP.FanOutletNode)));
-                    ShowContinueError(state, format("...Cooling coil inlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
+                    ShowContinueError(state, format("...Fan outlet node name         = {}", s_node->NodeID(thisMSHP.FanOutletNode)));
+                    ShowContinueError(state, format("...Cooling coil inlet node name = {}", s_node->NodeID(thisMSHP.CoolCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (CoolingCoilOutletNode != HeatingCoilInletNode) {
+                if (thisMSHP.CoolCoilAirOutletNode != thisMSHP.HeatCoilAirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
-                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(thisMSHP.CoolCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(thisMSHP.HeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (HeatingCoilOutletNode != SuppHeatCoilInletNode) {
+                if (thisMSHP.HeatCoilAirOutletNode != thisMSHP.SuppHeatCoilAirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(state,
                                       "When a blow through fan is specified, the heating coil outlet node name must be the same as the reheat coil "
                                       "inlet node name.");
-                    ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                    ShowContinueError(state, format("...Reheat coil inlet node name   = {}", state.dataLoopNodes->NodeID(SuppHeatCoilInletNode)));
+                    ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(thisMSHP.HeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Reheat coil inlet node name   = {}", s_node->NodeID(thisMSHP.SuppHeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (SuppHeatCoilOutletNode != thisMSHP.AirOutletNodeNum) {
+                if (thisMSHP.SuppHeatCoilAirOutletNode != thisMSHP.AirOutletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(state, format("The supplemental heating coil outlet node name must be the same as the {}", cAlphaFields(4)));
                     ShowContinueError(
-                        state, format("...Supplemental heating coil outlet node name   = {}", state.dataLoopNodes->NodeID(SuppHeatCoilOutletNode)));
-                    ShowContinueError(state, format("...{} = {}", cAlphaFields(4), state.dataLoopNodes->NodeID(thisMSHP.AirOutletNodeNum)));
+                        state, format("...Supplemental heating coil outlet node name   = {}", s_node->NodeID(thisMSHP.SuppHeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("...{} = {}", cAlphaFields(4), s_node->NodeID(thisMSHP.AirOutletNode)));
                     ErrorsFound = true;
                 }
             } else {
-                if (CoolingCoilInletNode != thisMSHP.AirInletNodeNum) {
+                if (thisMSHP.CoolCoilAirInletNode != thisMSHP.AirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(
                         state,
                         format("When a draw through fan is specified, the cooling coil inlet node name must be the same as the {}", cAlphaFields(3)));
-                    ShowContinueError(state, format("...Cooling coil inlet node name  = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
-                    ShowContinueError(state, format("...{} = {}", cAlphaFields(3), state.dataLoopNodes->NodeID(thisMSHP.AirInletNodeNum)));
+                    ShowContinueError(state, format("...Cooling coil inlet node name  = {}", s_node->NodeID(thisMSHP.CoolCoilAirInletNode)));
+                    ShowContinueError(state, format("...{} = {}", cAlphaFields(3), s_node->NodeID(thisMSHP.AirInletNode)));
                     ErrorsFound = true;
                 }
-                if (CoolingCoilOutletNode != HeatingCoilInletNode) {
+                if (thisMSHP.CoolCoilAirOutletNode != thisMSHP.HeatCoilAirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
-                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
-                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
+                    ShowContinueError(state, format("...Cooling coil outlet node name = {}", s_node->NodeID(thisMSHP.CoolCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Heating coil inlet node name  = {}", s_node->NodeID(thisMSHP.HeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (HeatingCoilOutletNode != thisMSHP.FanInletNode) {
+                if (thisMSHP.HeatCoilAirOutletNode != thisMSHP.FanInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(
                         state,
                         "When a draw through fan is specified, the heating coil outlet node name must be the same as the fan inlet node name.");
-                    ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
-                    ShowContinueError(state, format("...Fan inlet node name           = {}", state.dataLoopNodes->NodeID(thisMSHP.FanInletNode)));
+                    ShowContinueError(state, format("...Heating coil outlet node name = {}", s_node->NodeID(thisMSHP.HeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("...Fan inlet node name           = {}", s_node->NodeID(thisMSHP.FanInletNode)));
                     ErrorsFound = true;
                 }
-                if (thisMSHP.FanOutletNode != SuppHeatCoilInletNode) {
+                if (thisMSHP.FanOutletNode != thisMSHP.SuppHeatCoilAirInletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(
                         state, "When a draw through fan is specified, the fan outlet node name must be the same as the reheat coil inlet node name.");
-                    ShowContinueError(state, format("...Fan outlet node name        = {}", state.dataLoopNodes->NodeID(thisMSHP.FanOutletNode)));
-                    ShowContinueError(state, format("...Reheat coil inlet node name = {}", state.dataLoopNodes->NodeID(SuppHeatCoilInletNode)));
+                    ShowContinueError(state, format("...Fan outlet node name        = {}", s_node->NodeID(thisMSHP.FanOutletNode)));
+                    ShowContinueError(state, format("...Reheat coil inlet node name = {}", s_node->NodeID(thisMSHP.SuppHeatCoilAirInletNode)));
                     ErrorsFound = true;
                 }
-                if (SuppHeatCoilOutletNode != thisMSHP.AirOutletNodeNum) {
+                if (thisMSHP.SuppHeatCoilAirOutletNode != thisMSHP.AirOutletNode) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(state, format("The reheat coil outlet node name must be the same as the {}", cAlphaFields(4)));
-                    ShowContinueError(state, format("...Reheat coil outlet node name   = {}", state.dataLoopNodes->NodeID(SuppHeatCoilOutletNode)));
-                    ShowContinueError(state, format("...{} = {}", cAlphaFields(4), state.dataLoopNodes->NodeID(thisMSHP.AirOutletNodeNum)));
+                    ShowContinueError(state, format("...Reheat coil outlet node name   = {}", s_node->NodeID(thisMSHP.SuppHeatCoilAirOutletNode)));
+                    ShowContinueError(state, format("...{} = {}", cAlphaFields(4), s_node->NodeID(thisMSHP.AirOutletNode)));
                     ErrorsFound = true;
                 }
             }
 
             // Ensure the numbers of speeds defined in the parent object are equal to the numbers defined in coil objects
-            if (thisMSHP.HeatCoilType == MultiSpeedHeatingCoil) {
-                i = DXCoils::GetDXCoilNumberOfSpeeds(state, Alphas(10), Alphas(11), ErrorsFound);
-                if (thisMSHP.NumOfSpeedHeating != i) {
+            if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+                int numSpeeds = DXCoils::GetCoilNumberOfSpeeds(state, thisMSHP.HeatCoilNum);
+                if (thisMSHP.NumOfSpeedHeating != numSpeeds) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(
                         state, format("The {} is not equal to the number defined in {} = {}", cNumericFields(9), cAlphaFields(11), Alphas(11)));
                     ErrorsFound = true;
                 }
-            } else if (thisMSHP.HeatCoilType == HVAC::Coil_HeatingElectric_MultiStage || thisMSHP.HeatCoilType == HVAC::Coil_HeatingGas_MultiStage) {
-                i = HeatingCoils::GetHeatingCoilNumberOfStages(state, Alphas(10), Alphas(11), ErrorsFound);
-                if (thisMSHP.NumOfSpeedHeating != i) {
+            } else if (thisMSHP.heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                       thisMSHP.heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
+                int numSpeeds = HeatingCoils::GetCoilNumberOfStages(state, thisMSHP.HeatCoilNum);
+                if (thisMSHP.NumOfSpeedHeating != numSpeeds) {
                     ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                     ShowContinueError(
                         state, format("The {} is not equal to the number defined in {} = {}", cNumericFields(9), cAlphaFields(11), Alphas(11)));
                     ErrorsFound = true;
                 }
             }
-            i = DXCoils::GetDXCoilNumberOfSpeeds(state, Alphas(12), Alphas(13), ErrorsFound);
-            if (thisMSHP.NumOfSpeedCooling != i) {
+
+            int numSpeeds = DXCoils::GetCoilNumberOfSpeeds(state, thisMSHP.CoolCoilNum);
+            if (thisMSHP.NumOfSpeedCooling != numSpeeds) {
                 ShowSevereError(state, format("For {} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, thisMSHP.Name));
                 ShowContinueError(state,
                                   format("The {} is not equal to the number defined in {} = {}", cNumericFields(10), cAlphaFields(13), Alphas(13)));
@@ -1776,28 +1443,23 @@ namespace HVACMultiSpeedHeatPump {
 
         bool ErrorsFound(false);        // flag returned from mining call
         Real64 mdot(0.0);               // local temporary for mass flow rate (kg/s)
-        Real64 SteamDensity(0.0);       // density of steam at 100C, used for steam heating coils
         Real64 CoilMaxVolFlowRate(0.0); // coil fluid maximum volume flow rate
         Real64 QActual(0.0);            // coil actual capacity
 
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump;
-
-        int InNode = MSHeatPump(MSHeatPumpNum).AirInletNodeNum;
-        int OutNode = MSHeatPump(MSHeatPumpNum).AirOutletNodeNum;
-        int NumOfSpeedCooling = MSHeatPump(MSHeatPumpNum).NumOfSpeedCooling;
-        int NumOfSpeedHeating = MSHeatPump(MSHeatPumpNum).NumOfSpeedHeating;
+        auto &s_node = state.dataLoopNodes;
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
 
         ++state.dataHVACMultiSpdHP->AirLoopPass;
         if (state.dataHVACMultiSpdHP->AirLoopPass > 2) state.dataHVACMultiSpdHP->AirLoopPass = 1;
 
-        if (MSHeatPump(MSHeatPumpNum).MyPlantScantFlag && allocated(state.dataPlnt->PlantLoop)) {
+        if (mshp.MyPlantScantFlag && allocated(state.dataPlnt->PlantLoop)) {
             bool errFlag;
-            if (MSHeatPump(MSHeatPumpNum).HeatRecActive) {
+            if (mshp.HeatRecActive) {
                 errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        MSHeatPump(MSHeatPumpNum).Name,
+                                                        mshp.Name,
                                                         DataPlant::PlantEquipmentType::MultiSpeedHeatPumpRecovery,
-                                                        MSHeatPump(MSHeatPumpNum).HRPlantLoc,
+                                                        mshp.HRPlantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -1808,16 +1470,17 @@ namespace HVACMultiSpeedHeatPump {
                     ShowFatalError(state, "InitMSHeatPump: Program terminated for previous conditions.");
                 }
 
-                MSHeatPump(MSHeatPumpNum).MyPlantScantFlag = false;
+                mshp.MyPlantScantFlag = false;
             } else {
-                MSHeatPump(MSHeatPumpNum).MyPlantScantFlag = false;
+                mshp.MyPlantScantFlag = false;
             }
-            if (MSHeatPump(MSHeatPumpNum).HeatCoilType == HVAC::Coil_HeatingWater) {
+            
+            if (mshp.heatCoilType == HVAC::CoilType::HeatingWater) {
                 errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        MSHeatPump(MSHeatPumpNum).HeatCoilName,
+                                                        mshp.HeatCoilName,
                                                         DataPlant::PlantEquipmentType::CoilWaterSimpleHeating,
-                                                        MSHeatPump(MSHeatPumpNum).plantLoc,
+                                                        mshp.HeatCoilPlantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -1827,26 +1490,23 @@ namespace HVACMultiSpeedHeatPump {
                 if (errFlag) {
                     ShowFatalError(state, "InitMSHeatPump: Program terminated for previous conditions.");
                 }
-                MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow =
-                    WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound);
-
-                if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow > 0.0) {
-                    rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum)
-                              .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                    MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound) * rho;
+                mshp.HeatCoilMaxFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, mshp.HeatCoilNum);
+
+                if (mshp.HeatCoilMaxFluidFlow > 0.0) {
+                    mshp.HeatCoilMaxFluidFlow *=
+                      state.dataPlnt->PlantLoop(mshp.HeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
                 }
+
                 // fill outlet node for coil
-                MSHeatPump(MSHeatPumpNum).CoilOutletNode =
-                    DataPlant::CompData::getPlantComponent(state, MSHeatPump(MSHeatPumpNum).plantLoc).NodeNumOut;
-                MSHeatPump(MSHeatPumpNum).MyPlantScantFlag = false;
+                mshp.HeatCoilFluidOutletNode = DataPlant::CompData::getPlantComponent(state, mshp.HeatCoilPlantLoc).NodeNumOut;
+                mshp.MyPlantScantFlag = false;
 
-            } else if (MSHeatPump(MSHeatPumpNum).HeatCoilType == HVAC::Coil_HeatingSteam) {
+            } else if (mshp.heatCoilType == HVAC::CoilType::HeatingSteam) {
                 errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        MSHeatPump(MSHeatPumpNum).HeatCoilName,
+                                                        mshp.HeatCoilName,
                                                         DataPlant::PlantEquipmentType::CoilSteamAirHeating,
-                                                        MSHeatPump(MSHeatPumpNum).plantLoc,
+                                                        mshp.HeatCoilPlantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -1856,24 +1516,22 @@ namespace HVACMultiSpeedHeatPump {
                 if (errFlag) {
                     ShowFatalError(state, "InitMSHeatPump: Program terminated for previous conditions.");
                 }
-                MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow =
-                    SteamCoils::GetCoilMaxSteamFlowRate(state, MSHeatPump(MSHeatPumpNum).HeatCoilNum, ErrorsFound);
-                if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow > 0.0) {
-                    SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, RoutineName);
-                    MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow *= SteamDensity;
+                mshp.HeatCoilMaxFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, mshp.HeatCoilNum);
+                if (mshp.HeatCoilMaxFluidFlow > 0.0) {
+                    mshp.HeatCoilMaxFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                 }
 
                 // fill outlet node for coil
-                MSHeatPump(MSHeatPumpNum).CoilOutletNode =
-                    DataPlant::CompData::getPlantComponent(state, MSHeatPump(MSHeatPumpNum).plantLoc).NodeNumOut;
-                MSHeatPump(MSHeatPumpNum).MyPlantScantFlag = false;
+                mshp.HeatCoilFluidOutletNode = DataPlant::CompData::getPlantComponent(state, mshp.HeatCoilPlantLoc).NodeNumOut;
+                mshp.MyPlantScantFlag = false;
             }
-            if (MSHeatPump(MSHeatPumpNum).SuppHeatCoilType == HVAC::Coil_HeatingWater) {
+            
+            if (mshp.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
                 errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        MSHeatPump(MSHeatPumpNum).SuppHeatCoilName,
+                                                        mshp.SuppHeatCoilName,
                                                         DataPlant::PlantEquipmentType::CoilWaterSimpleHeating,
-                                                        MSHeatPump(MSHeatPumpNum).SuppPlantLoc,
+                                                        mshp.SuppHeatCoilPlantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -1883,27 +1541,23 @@ namespace HVACMultiSpeedHeatPump {
                 if (errFlag) {
                     ShowFatalError(state, "InitMSHeatPump: Program terminated for previous conditions.");
                 }
-                MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow =
-                    WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound);
-
-                if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow > 0.0) {
-                    rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum)
-                              .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                    MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound) *
-                        rho;
+                mshp.SuppHeatCoilMaxFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, mshp.SuppHeatCoilNum);
+
+                if (mshp.SuppHeatCoilMaxFluidFlow > 0.0) {
+                    mshp.SuppHeatCoilMaxFluidFlow *=
+                      state.dataPlnt->PlantLoop(mshp.SuppHeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
                 }
+                
                 // fill outlet node for coil
-                MSHeatPump(MSHeatPumpNum).SuppCoilOutletNode =
-                    DataPlant::CompData::getPlantComponent(state, MSHeatPump(MSHeatPumpNum).SuppPlantLoc).NodeNumOut;
-                MSHeatPump(MSHeatPumpNum).MyPlantScantFlag = false;
+                mshp.SuppHeatCoilFluidOutletNode = DataPlant::CompData::getPlantComponent(state, mshp.SuppHeatCoilPlantLoc).NodeNumOut;
+                mshp.MyPlantScantFlag = false;
 
-            } else if (MSHeatPump(MSHeatPumpNum).SuppHeatCoilType == HVAC::Coil_HeatingSteam) {
+            } else if (mshp.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                 errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        MSHeatPump(MSHeatPumpNum).SuppHeatCoilName,
+                                                        mshp.SuppHeatCoilName,
                                                         DataPlant::PlantEquipmentType::CoilSteamAirHeating,
-                                                        MSHeatPump(MSHeatPumpNum).SuppPlantLoc,
+                                                        mshp.SuppHeatCoilPlantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -1913,54 +1567,52 @@ namespace HVACMultiSpeedHeatPump {
                 if (errFlag) {
                     ShowFatalError(state, "InitMSHeatPump: Program terminated for previous conditions.");
                 }
-                MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow =
-                    SteamCoils::GetCoilMaxSteamFlowRate(state, MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum, ErrorsFound);
-                if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow > 0.0) {
-                    SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, RoutineName);
-                    MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow *= SteamDensity;
+
+                mshp.SuppHeatCoilMaxFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, mshp.SuppHeatCoilNum);
+                if (mshp.SuppHeatCoilMaxFluidFlow > 0.0) {
+                    mshp.SuppHeatCoilMaxFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                 }
 
                 // fill outlet node for coil
-                MSHeatPump(MSHeatPumpNum).SuppCoilOutletNode =
-                    DataPlant::CompData::getPlantComponent(state, MSHeatPump(MSHeatPumpNum).SuppPlantLoc).NodeNumOut;
-                MSHeatPump(MSHeatPumpNum).MyPlantScantFlag = false;
+                mshp.SuppHeatCoilFluidOutletNode = DataPlant::CompData::getPlantComponent(state, mshp.SuppHeatCoilPlantLoc).NodeNumOut;
+                mshp.MyPlantScantFlag = false;
             }
-        } else if (MSHeatPump(MSHeatPumpNum).MyPlantScantFlag && !state.dataGlobal->AnyPlantInModel) {
-            MSHeatPump(MSHeatPumpNum).MyPlantScantFlag = false;
+        } else if (mshp.MyPlantScantFlag && !state.dataGlobal->AnyPlantInModel) {
+            mshp.MyPlantScantFlag = false;
         }
 
-        if (!state.dataGlobal->SysSizingCalc && MSHeatPump(MSHeatPumpNum).MySizeFlag) {
-            MSHeatPump(MSHeatPumpNum).FanVolFlow = state.dataFans->fans(MSHeatPump(MSHeatPumpNum).FanNum)->maxAirFlowRate;
+        if (!state.dataGlobal->SysSizingCalc && mshp.MySizeFlag) {
+            mshp.FanVolFlow = state.dataFans->fans(mshp.FanNum)->maxAirFlowRate;
             SizeMSHeatPump(state, MSHeatPumpNum);
-            MSHeatPump(MSHeatPumpNum).FlowFraction = 1.0;
-            MSHeatPump(MSHeatPumpNum).MySizeFlag = false;
+            mshp.FlowFraction = 1.0;
+            mshp.MySizeFlag = false;
             // Pass the fan cycling schedule index up to the air loop. Set the air loop unitary system flag.
-            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).cycFanSched = MSHeatPump(MSHeatPumpNum).fanOpModeSched;
+            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).cycFanSched = mshp.fanOpModeSched;
             state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySys = true;
             state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySysSimulating =
                 false; // affects child coil sizing by allowing coil to size itself instead of parent telling coil what size to use
-            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = MSHeatPump(MSHeatPumpNum).fanOp;
+            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = mshp.fanOp;
         }
 
-        if (allocated(state.dataZoneEquip->ZoneEquipConfig) && MSHeatPump(MSHeatPumpNum).MyCheckFlag) {
-            int zoneNum = MSHeatPump(MSHeatPumpNum).ControlZoneNum;
-            int zoneInlet = MSHeatPump(MSHeatPumpNum).ZoneInletNode;
+        if (allocated(state.dataZoneEquip->ZoneEquipConfig) && mshp.MyCheckFlag) {
+            int zoneNum = mshp.ControlZoneNum;
+            int zoneInlet = mshp.ZoneInletNode;
             // setup furnace zone equipment sequence information based on finding matching air terminal
             if (state.dataZoneEquip->ZoneEquipConfig(zoneNum).EquipListIndex > 0) {
                 int coolingPriority = 0;
                 int heatingPriority = 0;
                 state.dataZoneEquip->ZoneEquipList(state.dataZoneEquip->ZoneEquipConfig(zoneNum).EquipListIndex)
                     .getPrioritiesForInletNode(state, zoneInlet, coolingPriority, heatingPriority);
-                MSHeatPump(MSHeatPumpNum).ZoneSequenceCoolingNum = coolingPriority;
-                MSHeatPump(MSHeatPumpNum).ZoneSequenceHeatingNum = heatingPriority;
+                mshp.ZoneSequenceCoolingNum = coolingPriority;
+                mshp.ZoneSequenceHeatingNum = heatingPriority;
             }
-            MSHeatPump(MSHeatPumpNum).MyCheckFlag = false;
-            if (MSHeatPump(MSHeatPumpNum).ZoneSequenceCoolingNum == 0 || MSHeatPump(MSHeatPumpNum).ZoneSequenceHeatingNum == 0) {
+            mshp.MyCheckFlag = false;
+            if (mshp.ZoneSequenceCoolingNum == 0 || mshp.ZoneSequenceHeatingNum == 0) {
                 ShowSevereError(state,
                                 format("AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed, \"{}\": Airloop air terminal in the zone equipment list for "
                                        "zone = {} not found or is not allowed Zone Equipment Cooling or Heating Sequence = 0.",
-                                       MSHeatPump(MSHeatPumpNum).Name,
-                                       MSHeatPump(MSHeatPumpNum).ControlZoneName));
+                                       mshp.Name,
+                                       mshp.ControlZoneName));
                 ShowFatalError(state,
                                "Subroutine InitMSHeatPump: Errors found in getting AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed input.  Preceding "
                                "condition(s) causes termination.");
@@ -1970,7 +1622,7 @@ namespace HVACMultiSpeedHeatPump {
         // Find the number of zones (zone Inlet Nodes) attached to an air loop from the air loop number
         NumAirLoopZones =
             state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).NumZonesCooled + state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).NumZonesHeated;
-        if (allocated(state.dataAirLoop->AirToZoneNodeInfo) && MSHeatPump(MSHeatPumpNum).MyFlowFracFlag) {
+        if (allocated(state.dataAirLoop->AirToZoneNodeInfo) && mshp.MyFlowFracFlag) {
             state.dataHVACMultiSpdHP->FlowFracFlagReady = true;
             for (int ZoneInSysIndex = 1; ZoneInSysIndex <= NumAirLoopZones; ++ZoneInSysIndex) {
                 // zone inlet nodes for cooling
@@ -1993,266 +1645,262 @@ namespace HVACMultiSpeedHeatPump {
             SumOfMassFlowRateMax = 0.0; // initialize the sum of the maximum flows
             for (int ZoneInSysIndex = 1; ZoneInSysIndex <= NumAirLoopZones; ++ZoneInSysIndex) {
                 int ZoneInletNodeNum = state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).TermUnitCoolInletNodes(ZoneInSysIndex);
-                SumOfMassFlowRateMax += state.dataLoopNodes->Node(ZoneInletNodeNum).MassFlowRateMax;
-                if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).CoolCtrlZoneNums(ZoneInSysIndex) == MSHeatPump(MSHeatPumpNum).ControlZoneNum) {
-                    CntrlZoneTerminalUnitMassFlowRateMax = state.dataLoopNodes->Node(ZoneInletNodeNum).MassFlowRateMax;
+                SumOfMassFlowRateMax += s_node->Node(ZoneInletNodeNum).MassFlowRateMax;
+                if (state.dataAirLoop->AirToZoneNodeInfo(AirLoopNum).CoolCtrlZoneNums(ZoneInSysIndex) == mshp.ControlZoneNum) {
+                    CntrlZoneTerminalUnitMassFlowRateMax = s_node->Node(ZoneInletNodeNum).MassFlowRateMax;
                 }
             }
-            if (SumOfMassFlowRateMax != 0.0 && MSHeatPump(MSHeatPumpNum).MyFlowFracFlag) {
+            if (SumOfMassFlowRateMax != 0.0 && mshp.MyFlowFracFlag) {
                 if (CntrlZoneTerminalUnitMassFlowRateMax >= HVAC::SmallAirVolFlow) {
-                    MSHeatPump(MSHeatPumpNum).FlowFraction = CntrlZoneTerminalUnitMassFlowRateMax / SumOfMassFlowRateMax;
+                    mshp.FlowFraction = CntrlZoneTerminalUnitMassFlowRateMax / SumOfMassFlowRateMax;
                 } else {
-                    ShowSevereError(state, format("{} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump(MSHeatPumpNum).Name));
+                    ShowSevereError(state, format("{} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
                     ShowContinueError(state, " The Fraction of Supply Air Flow That Goes Through the Controlling Zone is set to 1.");
                 }
                 BaseSizer::reportSizerOutput(state,
                                              state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                             MSHeatPump(MSHeatPumpNum).Name,
+                                             mshp.Name,
                                              "Fraction of Supply Air Flow That Goes Through the Controlling Zone",
-                                             MSHeatPump(MSHeatPumpNum).FlowFraction);
-                MSHeatPump(MSHeatPumpNum).MyFlowFracFlag = false;
+                                             mshp.FlowFraction);
+                mshp.MyFlowFracFlag = false;
             }
         }
 
         // Do the Begin Environment initializations
-        if (state.dataGlobal->BeginEnvrnFlag && MSHeatPump(MSHeatPumpNum).MyEnvrnFlag) {
+        if (state.dataGlobal->BeginEnvrnFlag && mshp.MyEnvrnFlag) {
             RhoAir = state.dataEnvrn->StdRhoAir;
             // set the mass flow rates from the input volume flow rates
-            for (i = 1; i <= NumOfSpeedCooling; ++i) {
-                MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(i) = RhoAir * MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(i);
+            for (i = 1; i <= mshp.NumOfSpeedCooling; ++i) {
+                mshp.CoolMassFlowRate(i) = RhoAir * mshp.CoolVolumeFlowRate(i);
             }
-            for (i = 1; i <= NumOfSpeedHeating; ++i) {
-                MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(i) = RhoAir * MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(i);
+            for (i = 1; i <= mshp.NumOfSpeedHeating; ++i) {
+                mshp.HeatMassFlowRate(i) = RhoAir * mshp.HeatVolumeFlowRate(i);
             }
-            MSHeatPump(MSHeatPumpNum).IdleMassFlowRate = RhoAir * MSHeatPump(MSHeatPumpNum).IdleVolumeAirRate;
+            mshp.IdleMassFlowRate = RhoAir * mshp.IdleVolumeAirRate;
             // set the node max and min mass flow rates
-            state.dataLoopNodes->Node(InNode).MassFlowRateMax =
-                max(MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(NumOfSpeedCooling), MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(NumOfSpeedHeating));
-            state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail =
-                max(MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(NumOfSpeedCooling), MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(NumOfSpeedHeating));
-            state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMinAvail = 0.0;
-            state.dataLoopNodes->Node(OutNode) = state.dataLoopNodes->Node(InNode);
-            MSHeatPump(MSHeatPumpNum).LoadLoss = 0.0;
-
-            if ((MSHeatPump(MSHeatPumpNum).HeatRecActive) && (!MSHeatPump(MSHeatPumpNum).MyPlantScantFlag)) {
-
-                rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum)
+            s_node->Node(mshp.AirInletNode).MassFlowRateMax =
+                max(mshp.CoolMassFlowRate(mshp.NumOfSpeedCooling), mshp.HeatMassFlowRate(mshp.NumOfSpeedHeating));
+            s_node->Node(mshp.AirInletNode).MassFlowRateMaxAvail =
+                max(mshp.CoolMassFlowRate(mshp.NumOfSpeedCooling), mshp.HeatMassFlowRate(mshp.NumOfSpeedHeating));
+            s_node->Node(mshp.AirInletNode).MassFlowRateMin = 0.0;
+            s_node->Node(mshp.AirInletNode).MassFlowRateMinAvail = 0.0;
+            s_node->Node(mshp.AirOutletNode) = s_node->Node(mshp.AirInletNode);
+            mshp.LoadLoss = 0.0;
+
+            if ((mshp.HeatRecActive) && (!mshp.MyPlantScantFlag)) {
+
+                rho = state.dataPlnt->PlantLoop(mshp.HRPlantLoc.loopNum)
                           .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
 
-                MSHeatPump(MSHeatPumpNum).DesignHeatRecMassFlowRate = MSHeatPump(MSHeatPumpNum).DesignHeatRecFlowRate * rho;
+                mshp.DesignHeatRecMassFlowRate = mshp.DesignHeatRecFlowRate * rho;
 
                 PlantUtilities::InitComponentNodes(state,
                                                    0.0,
-                                                   MSHeatPump(MSHeatPumpNum).DesignHeatRecMassFlowRate,
-                                                   MSHeatPump(MSHeatPumpNum).HeatRecInletNodeNum,
-                                                   MSHeatPump(MSHeatPumpNum).HeatRecOutletNodeNum);
+                                                   mshp.DesignHeatRecMassFlowRate,
+                                                   mshp.HeatRecFluidInletNode,
+                                                   mshp.HeatRecFluidOutletNode);
             }
-            if (MSHeatPump(MSHeatPumpNum).CoilControlNode > 0) {
-                if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow == DataSizing::AutoSize) {
-                    if (MSHeatPump(MSHeatPumpNum).HeatCoilType == HVAC::Coil_HeatingWater) {
-                        WaterCoils::SimulateWaterCoilComponents(
-                            state, MSHeatPump(MSHeatPumpNum).HeatCoilName, FirstHVACIteration, MSHeatPump(MSHeatPumpNum).HeatCoilNum);
+            
+            if (mshp.HeatCoilControlNode > 0) {
+                if (mshp.HeatCoilMaxFluidFlow == DataSizing::AutoSize) {
+                  if (mshp.heatCoilType == HVAC::CoilType::HeatingWater) {
+                        WaterCoils::SimulateWaterCoilComponents(state, mshp.HeatCoilName, FirstHVACIteration, mshp.HeatCoilNum);
 
-                        CoilMaxVolFlowRate =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound);
+                        mshp.HeatCoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, mshp.HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum)
-                                      .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                            MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow = CoilMaxVolFlowRate * rho;
+                            mshp.HeatCoilMaxFluidFlow = mshp.HeatCoilMaxVolFlowRate *
+                                state.dataPlnt->PlantLoop(mshp.HeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
                         }
                         PlantUtilities::InitComponentNodes(state,
                                                            0.0,
-                                                           MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow,
-                                                           MSHeatPump(MSHeatPumpNum).CoilControlNode,
-                                                           MSHeatPump(MSHeatPumpNum).CoilOutletNode);
-                    }
-                    if (MSHeatPump(MSHeatPumpNum).HeatCoilType == HVAC::Coil_HeatingSteam) {
+                                                           mshp.HeatCoilMaxFluidFlow,
+                                                           mshp.HeatCoilControlNode,
+                                                           mshp.HeatCoilFluidOutletNode);
+
+                  } else if (mshp.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
                         SteamCoils::SimulateSteamCoilComponents(state,
-                                                                MSHeatPump(MSHeatPumpNum).HeatCoilName,
+                                                                mshp.HeatCoilName,
                                                                 FirstHVACIteration,
-                                                                MSHeatPump(MSHeatPumpNum).HeatCoilNum,
+                                                                mshp.HeatCoilNum,
                                                                 1.0,
                                                                 QActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                        CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, MSHeatPump(MSHeatPumpNum).HeatCoilNum, ErrorsFound);
 
-                        if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, RoutineName);
-                            MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;
+                        mshp.HeatCoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, mshp.HeatCoilNum);
+
+                        if (mshp.HeatCoilMaxVolFlowRate != DataSizing::AutoSize) {
+                            mshp.HeatCoilMaxFluidFlow = mshp.HeatCoilMaxVolFlowRate *
+                                Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                         }
                         PlantUtilities::InitComponentNodes(state,
                                                            0.0,
-                                                           MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow,
-                                                           MSHeatPump(MSHeatPumpNum).CoilControlNode,
-                                                           MSHeatPump(MSHeatPumpNum).CoilOutletNode);
+                                                           mshp.HeatCoilMaxFluidFlow,
+                                                           mshp.HeatCoilControlNode,
+                                                           mshp.HeatCoilFluidOutletNode);
                     }
                 }
             }
-            if (MSHeatPump(MSHeatPumpNum).SuppCoilControlNode > 0) {
-                if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
-                    if (MSHeatPump(MSHeatPumpNum).SuppHeatCoilType == HVAC::Coil_HeatingWater) {
-                        WaterCoils::SimulateWaterCoilComponents(
-                            state, MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, FirstHVACIteration, MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum);
+            
+            if (mshp.SuppHeatCoilControlNode > 0) {
+                if (mshp.SuppHeatCoilMaxFluidFlow == DataSizing::AutoSize) {
+                    if (mshp.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
+                        WaterCoils::SimulateWaterCoilComponents(state, mshp.SuppHeatCoilName, FirstHVACIteration, mshp.SuppHeatCoilNum);
 
-                        CoilMaxVolFlowRate =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound);
-                        if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum)
-                                      .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                            MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho;
+                        mshp.SuppHeatCoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, mshp.SuppHeatCoilNum);
+                        if (mshp.SuppHeatCoilMaxVolFlowRate != DataSizing::AutoSize) {
+                            mshp.SuppHeatCoilMaxFluidFlow = mshp.SuppHeatCoilMaxVolFlowRate *
+                              state.dataPlnt->PlantLoop(mshp.SuppHeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
                         }
                         PlantUtilities::InitComponentNodes(state,
                                                            0.0,
-                                                           MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow,
-                                                           MSHeatPump(MSHeatPumpNum).SuppCoilControlNode,
-                                                           MSHeatPump(MSHeatPumpNum).SuppCoilOutletNode);
-                    }
-                    if (MSHeatPump(MSHeatPumpNum).SuppHeatCoilType == HVAC::Coil_HeatingSteam) {
+                                                           mshp.SuppHeatCoilMaxFluidFlow,
+                                                           mshp.SuppHeatCoilControlNode,
+                                                           mshp.SuppHeatCoilFluidOutletNode);
+
+                    } else if (mshp.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
 
                         SteamCoils::SimulateSteamCoilComponents(state,
-                                                                MSHeatPump(MSHeatPumpNum).SuppHeatCoilName,
+                                                                mshp.SuppHeatCoilName,
                                                                 FirstHVACIteration,
-                                                                MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum,
+                                                                mshp.SuppHeatCoilNum,
                                                                 1.0,
                                                                 QActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                        CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum, ErrorsFound);
-
-                        if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACMultiSpdHP->TempSteamIn, 1.0, RoutineName);
-                            MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;
+                        mshp.SuppHeatCoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, mshp.SuppHeatCoilNum);
+                        if (mshp.SuppHeatCoilMaxVolFlowRate != DataSizing::AutoSize) {
+                            mshp.SuppHeatCoilMaxFluidFlow = mshp.SuppHeatCoilMaxVolFlowRate *
+                              Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
+                              
                         }
                         PlantUtilities::InitComponentNodes(state,
                                                            0.0,
-                                                           MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow,
-                                                           MSHeatPump(MSHeatPumpNum).SuppCoilControlNode,
-                                                           MSHeatPump(MSHeatPumpNum).SuppCoilOutletNode);
+                                                           mshp.SuppHeatCoilMaxFluidFlow,
+                                                           mshp.SuppHeatCoilControlNode,
+                                                           mshp.SuppHeatCoilFluidOutletNode);
                     }
                 }
             }
-            MSHeatPump(MSHeatPumpNum).MyEnvrnFlag = false;
+            mshp.MyEnvrnFlag = false;
         } // end one time inits
 
         if (!state.dataGlobal->BeginEnvrnFlag) {
-            MSHeatPump(MSHeatPumpNum).MyEnvrnFlag = true;
+            mshp.MyEnvrnFlag = true;
         }
 
         // IF MSHP system was not autosized and the fan is autosized, check that fan volumetric flow rate is greater than MSHP flow rates
-        if (!state.dataGlobal->DoingSizing && MSHeatPump(MSHeatPumpNum).CheckFanFlow) {
+        if (!state.dataGlobal->DoingSizing && mshp.CheckFanFlow) {
             state.dataHVACMultiSpdHP->CurrentModuleObject = "AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed";
-            MSHeatPump(MSHeatPumpNum).FanVolFlow = state.dataFans->fans(MSHeatPump(MSHeatPumpNum).FanNum)->maxAirFlowRate;
-            if (MSHeatPump(MSHeatPumpNum).FanVolFlow != DataSizing::AutoSize) {
+            mshp.FanVolFlow = state.dataFans->fans(mshp.FanNum)->maxAirFlowRate;
+            if (mshp.FanVolFlow != DataSizing::AutoSize) {
                 //     Check fan versus system supply air flow rates
-                if (MSHeatPump(MSHeatPumpNum).FanVolFlow < MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(NumOfSpeedCooling)) {
+                if (mshp.FanVolFlow < mshp.CoolVolumeFlowRate(mshp.NumOfSpeedCooling)) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the MSHP system air flow rate when cooling is "
                                             "required ({:.7T}).",
                                             state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                            MSHeatPump(MSHeatPumpNum).FanVolFlow,
-                                            MSHeatPump(MSHeatPumpNum).FanName,
-                                            MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(NumOfSpeedCooling)));
+                                            mshp.FanVolFlow,
+                                            mshp.FanName,
+                                            mshp.CoolVolumeFlowRate(mshp.NumOfSpeedCooling)));
                     ShowContinueError(
                         state, " The MSHP system flow rate when cooling is required is reset to the fan flow rate and the simulation continues.");
                     ShowContinueError(state,
-                                      format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump(MSHeatPumpNum).Name));
-                    MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(NumOfSpeedCooling) = MSHeatPump(MSHeatPumpNum).FanVolFlow;
+                                      format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
+                    mshp.CoolVolumeFlowRate(mshp.NumOfSpeedCooling) = mshp.FanVolFlow;
                     // Check flow rates in other speeds and ensure flow rates are not above the max flow rate
-                    for (i = NumOfSpeedCooling - 1; i >= 1; --i) {
-                        if (MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(i) > MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(i + 1)) {
+                    for (i = mshp.NumOfSpeedCooling - 1; i >= 1; --i) {
+                        if (mshp.CoolVolumeFlowRate(i) > mshp.CoolVolumeFlowRate(i + 1)) {
                             ShowContinueError(state,
                                               format(" The MSHP system flow rate when cooling is required is reset to the flow rate at higher speed "
                                                      "and the simulation continues at Speed{}.",
                                                      i));
                             ShowContinueError(
-                                state, format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump(MSHeatPumpNum).Name));
-                            MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(i) = MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(i + 1);
+                                state, format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
+                            mshp.CoolVolumeFlowRate(i) = mshp.CoolVolumeFlowRate(i + 1);
                         }
                     }
                 }
-                if (MSHeatPump(MSHeatPumpNum).FanVolFlow < MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(NumOfSpeedHeating)) {
+                if (mshp.FanVolFlow < mshp.HeatVolumeFlowRate(mshp.NumOfSpeedHeating)) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the MSHP system air flow rate when heating is "
                                             "required ({:.7T}).",
                                             state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                            MSHeatPump(MSHeatPumpNum).FanVolFlow,
-                                            MSHeatPump(MSHeatPumpNum).FanName,
-                                            MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(NumOfSpeedHeating)));
+                                            mshp.FanVolFlow,
+                                            mshp.FanName,
+                                            mshp.HeatVolumeFlowRate(mshp.NumOfSpeedHeating)));
                     ShowContinueError(
                         state, " The MSHP system flow rate when heating is required is reset to the fan flow rate and the simulation continues.");
                     ShowContinueError(state,
-                                      format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump(MSHeatPumpNum).Name));
-                    MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(NumOfSpeedHeating) = MSHeatPump(MSHeatPumpNum).FanVolFlow;
-                    for (i = NumOfSpeedHeating - 1; i >= 1; --i) {
-                        if (MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(i) > MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(i + 1)) {
+                                      format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
+                    mshp.HeatVolumeFlowRate(mshp.NumOfSpeedHeating) = mshp.FanVolFlow;
+                    for (i = mshp.NumOfSpeedHeating - 1; i >= 1; --i) {
+                        if (mshp.HeatVolumeFlowRate(i) > mshp.HeatVolumeFlowRate(i + 1)) {
                             ShowContinueError(state,
                                               format(" The MSHP system flow rate when heating is required is reset to the flow rate at higher speed "
                                                      "and the simulation continues at Speed{}.",
                                                      i));
                             ShowContinueError(
                                 state,
-                                format(" Occurs in {} system = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump(MSHeatPumpNum).Name));
-                            MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(i) = MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(i + 1);
+                                format(" Occurs in {} system = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
+                            mshp.HeatVolumeFlowRate(i) = mshp.HeatVolumeFlowRate(i + 1);
                         }
                     }
                 }
-                if (MSHeatPump(MSHeatPumpNum).FanVolFlow < MSHeatPump(MSHeatPumpNum).IdleVolumeAirRate &&
-                    MSHeatPump(MSHeatPumpNum).IdleVolumeAirRate != 0.0) {
+                if (mshp.FanVolFlow < mshp.IdleVolumeAirRate &&
+                    mshp.IdleVolumeAirRate != 0.0) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the MSHP system air flow rate when no heating "
                                             "or cooling is needed ({:.7T}).",
                                             state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                            MSHeatPump(MSHeatPumpNum).FanVolFlow,
-                                            MSHeatPump(MSHeatPumpNum).FanName,
-                                            MSHeatPump(MSHeatPumpNum).IdleVolumeAirRate));
+                                            mshp.FanVolFlow,
+                                            mshp.FanName,
+                                            mshp.IdleVolumeAirRate));
                     ShowContinueError(state,
                                       " The MSHP system flow rate when no heating or cooling is needed is reset to the fan flow rate and the "
                                       "simulation continues.");
                     ShowContinueError(state,
-                                      format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump(MSHeatPumpNum).Name));
-                    MSHeatPump(MSHeatPumpNum).IdleVolumeAirRate = MSHeatPump(MSHeatPumpNum).FanVolFlow;
+                                      format(" Occurs in {} = {}", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
+                    mshp.IdleVolumeAirRate = mshp.FanVolFlow;
                 }
                 RhoAir = state.dataEnvrn->StdRhoAir;
                 // set the mass flow rates from the reset volume flow rates
-                for (i = 1; i <= NumOfSpeedCooling; ++i) {
-                    MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(i) = RhoAir * MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(i);
-                    if (MSHeatPump(MSHeatPumpNum).FanVolFlow > 0.0) {
-                        MSHeatPump(MSHeatPumpNum).CoolingSpeedRatio(i) =
-                            MSHeatPump(MSHeatPumpNum).CoolVolumeFlowRate(i) / MSHeatPump(MSHeatPumpNum).FanVolFlow;
+                for (i = 1; i <= mshp.NumOfSpeedCooling; ++i) {
+                    mshp.CoolMassFlowRate(i) = RhoAir * mshp.CoolVolumeFlowRate(i);
+                    if (mshp.FanVolFlow > 0.0) {
+                        mshp.CoolingSpeedRatio(i) =
+                            mshp.CoolVolumeFlowRate(i) / mshp.FanVolFlow;
                     }
                 }
-                for (i = 1; i <= NumOfSpeedHeating; ++i) {
-                    MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(i) = RhoAir * MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(i);
-                    if (MSHeatPump(MSHeatPumpNum).FanVolFlow > 0.0) {
-                        MSHeatPump(MSHeatPumpNum).HeatingSpeedRatio(i) =
-                            MSHeatPump(MSHeatPumpNum).HeatVolumeFlowRate(i) / MSHeatPump(MSHeatPumpNum).FanVolFlow;
+                for (i = 1; i <= mshp.NumOfSpeedHeating; ++i) {
+                    mshp.HeatMassFlowRate(i) = RhoAir * mshp.HeatVolumeFlowRate(i);
+                    if (mshp.FanVolFlow > 0.0) {
+                        mshp.HeatingSpeedRatio(i) =
+                            mshp.HeatVolumeFlowRate(i) / mshp.FanVolFlow;
                     }
                 }
-                MSHeatPump(MSHeatPumpNum).IdleMassFlowRate = RhoAir * MSHeatPump(MSHeatPumpNum).IdleVolumeAirRate;
-                if (MSHeatPump(MSHeatPumpNum).FanVolFlow > 0.0) {
-                    MSHeatPump(MSHeatPumpNum).IdleSpeedRatio = MSHeatPump(MSHeatPumpNum).IdleVolumeAirRate / MSHeatPump(MSHeatPumpNum).FanVolFlow;
+                mshp.IdleMassFlowRate = RhoAir * mshp.IdleVolumeAirRate;
+                if (mshp.FanVolFlow > 0.0) {
+                    mshp.IdleSpeedRatio = mshp.IdleVolumeAirRate / mshp.FanVolFlow;
                 }
                 // set the node max and min mass flow rates based on reset volume flow rates
-                state.dataLoopNodes->Node(InNode).MassFlowRateMax =
-                    max(MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(NumOfSpeedCooling), MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(NumOfSpeedHeating));
-                state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail =
-                    max(MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(NumOfSpeedCooling), MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(NumOfSpeedHeating));
-                state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
-                state.dataLoopNodes->Node(InNode).MassFlowRateMinAvail = 0.0;
-                state.dataLoopNodes->Node(OutNode) = state.dataLoopNodes->Node(InNode);
-                MSHeatPump(MSHeatPumpNum).CheckFanFlow = false;
+                s_node->Node(mshp.AirInletNode).MassFlowRateMax =
+                    max(mshp.CoolMassFlowRate(mshp.NumOfSpeedCooling), mshp.HeatMassFlowRate(mshp.NumOfSpeedHeating));
+                s_node->Node(mshp.AirInletNode).MassFlowRateMaxAvail =
+                    max(mshp.CoolMassFlowRate(mshp.NumOfSpeedCooling), mshp.HeatMassFlowRate(mshp.NumOfSpeedHeating));
+                s_node->Node(mshp.AirInletNode).MassFlowRateMin = 0.0;
+                s_node->Node(mshp.AirInletNode).MassFlowRateMinAvail = 0.0;
+                s_node->Node(mshp.AirOutletNode) = s_node->Node(mshp.AirInletNode);
+                mshp.CheckFanFlow = false;
             }
         }
 
-        if (MSHeatPump(MSHeatPumpNum).fanOpModeSched != nullptr) {
-            MSHeatPump(MSHeatPumpNum).fanOp =
-                (MSHeatPump(MSHeatPumpNum).fanOpModeSched->getCurrentVal() == 0.0) ? HVAC::FanOp::Cycling : HVAC::FanOp::Continuous;
+        if (mshp.fanOpModeSched != nullptr) {
+            mshp.fanOp = (mshp.fanOpModeSched->getCurrentVal() == 0.0) ? HVAC::FanOp::Cycling : HVAC::FanOp::Continuous;
         }
 
         // Calculate air distribution losses
         if (!FirstHVACIteration && state.dataHVACMultiSpdHP->AirLoopPass == 1) {
-            int ZoneInNode = MSHeatPump(MSHeatPumpNum).ZoneInletNode;
-            DeltaMassRate = state.dataLoopNodes->Node(OutNode).MassFlowRate -
-                            state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / MSHeatPump(MSHeatPumpNum).FlowFraction;
+            int ZoneInNode = mshp.ZoneInletNode;
+            DeltaMassRate = s_node->Node(mshp.AirOutletNode).MassFlowRate -
+                            s_node->Node(ZoneInNode).MassFlowRate / mshp.FlowFraction;
             if (DeltaMassRate < 0.0) DeltaMassRate = 0.0;
             Real64 MassFlowRate(0.0);        // parent mass flow rate
             Real64 LatentOutput(0.0);        // latent output rate
@@ -2260,37 +1908,37 @@ namespace HVACMultiSpeedHeatPump {
             Real64 SensibleOutputDelta(0.0); // delta sensible output rate
             Real64 LatentOutputDelta(0.0);   // delta latent output rate
             Real64 TotalOutputDelta(0.0);    // delta total output rate
-            MassFlowRate = state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / MSHeatPump(MSHeatPumpNum).FlowFraction;
-            Real64 MinHumRat = state.dataLoopNodes->Node(ZoneInNode).HumRat;
-            if (state.dataLoopNodes->Node(OutNode).Temp < state.dataLoopNodes->Node(MSHeatPump(MSHeatPumpNum).NodeNumOfControlledZone).Temp)
-                MinHumRat = state.dataLoopNodes->Node(OutNode).HumRat;
+            MassFlowRate = s_node->Node(ZoneInNode).MassFlowRate / mshp.FlowFraction;
+            Real64 MinHumRat = s_node->Node(ZoneInNode).HumRat;
+            if (s_node->Node(mshp.AirOutletNode).Temp < s_node->Node(mshp.NodeNumOfControlledZone).Temp)
+                MinHumRat = s_node->Node(mshp.AirOutletNode).HumRat;
             CalcZoneSensibleLatentOutput(MassFlowRate,
-                                         state.dataLoopNodes->Node(OutNode).Temp,
+                                         s_node->Node(mshp.AirOutletNode).Temp,
                                          MinHumRat,
-                                         state.dataLoopNodes->Node(ZoneInNode).Temp,
+                                         s_node->Node(ZoneInNode).Temp,
                                          MinHumRat,
-                                         MSHeatPump(MSHeatPumpNum).LoadLoss,
+                                         mshp.LoadLoss,
                                          LatentOutput,
                                          TotalOutput);
             CalcZoneSensibleLatentOutput(DeltaMassRate,
-                                         state.dataLoopNodes->Node(OutNode).Temp,
+                                         s_node->Node(mshp.AirOutletNode).Temp,
                                          MinHumRat,
-                                         state.dataLoopNodes->Node(MSHeatPump(MSHeatPumpNum).NodeNumOfControlledZone).Temp,
+                                         s_node->Node(mshp.NodeNumOfControlledZone).Temp,
                                          MinHumRat,
                                          SensibleOutputDelta,
                                          LatentOutputDelta,
                                          TotalOutputDelta);
-            MSHeatPump(MSHeatPumpNum).LoadLoss = MSHeatPump(MSHeatPumpNum).LoadLoss + SensibleOutputDelta;
-            if (std::abs(MSHeatPump(MSHeatPumpNum).LoadLoss) < 1.0e-6) MSHeatPump(MSHeatPumpNum).LoadLoss = 0.0;
+            mshp.LoadLoss = mshp.LoadLoss + SensibleOutputDelta;
+            if (std::abs(mshp.LoadLoss) < 1.0e-6) mshp.LoadLoss = 0.0;
         }
 
         // Returns load only for zones requesting cooling (heating). If in deadband, Qzoneload = 0.
-        ZoneNum = MSHeatPump(MSHeatPumpNum).ControlZoneNum;
-        if ((MSHeatPump(MSHeatPumpNum).ZoneSequenceCoolingNum > 0) && (MSHeatPump(MSHeatPumpNum).ZoneSequenceHeatingNum > 0)) {
-            ZoneLoadToCoolSPSequenced = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(MSHeatPump(MSHeatPumpNum).ControlZoneNum)
-                                            .SequencedOutputRequiredToCoolingSP(MSHeatPump(MSHeatPumpNum).ZoneSequenceCoolingNum);
-            ZoneLoadToHeatSPSequenced = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(MSHeatPump(MSHeatPumpNum).ControlZoneNum)
-                                            .SequencedOutputRequiredToHeatingSP(MSHeatPump(MSHeatPumpNum).ZoneSequenceHeatingNum);
+        ZoneNum = mshp.ControlZoneNum;
+        if ((mshp.ZoneSequenceCoolingNum > 0) && (mshp.ZoneSequenceHeatingNum > 0)) {
+            ZoneLoadToCoolSPSequenced = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(mshp.ControlZoneNum)
+                                            .SequencedOutputRequiredToCoolingSP(mshp.ZoneSequenceCoolingNum);
+            ZoneLoadToHeatSPSequenced = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(mshp.ControlZoneNum)
+                                            .SequencedOutputRequiredToHeatingSP(mshp.ZoneSequenceHeatingNum);
             if (ZoneLoadToHeatSPSequenced > HVAC::SmallLoad && ZoneLoadToCoolSPSequenced > HVAC::SmallLoad) {
                 QZnReq = ZoneLoadToHeatSPSequenced;
             } else if (ZoneLoadToHeatSPSequenced < (-1.0 * HVAC::SmallLoad) && ZoneLoadToCoolSPSequenced < (-1.0 * HVAC::SmallLoad)) {
@@ -2300,60 +1948,60 @@ namespace HVACMultiSpeedHeatPump {
             } else {
                 QZnReq = 0.0; // Autodesk:Init Case added to prevent use of uninitialized value (occurred in MultiSpeedACFurnace example)
             }
-            QZnReq /= MSHeatPump(MSHeatPumpNum).FlowFraction;
+            QZnReq /= mshp.FlowFraction;
         } else {
-            QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputRequired / MSHeatPump(MSHeatPumpNum).FlowFraction;
+            QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputRequired / mshp.FlowFraction;
         }
         if (state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) QZnReq = 0.0;
 
         if (QZnReq > HVAC::SmallLoad) {
-            MSHeatPump(MSHeatPumpNum).HeatCoolMode = ModeOfOperation::HeatingMode;
+            mshp.HeatCoolMode = ModeOfOperation::HeatingMode;
         } else if (QZnReq < (-1.0 * HVAC::SmallLoad)) {
-            MSHeatPump(MSHeatPumpNum).HeatCoolMode = ModeOfOperation::CoolingMode;
+            mshp.HeatCoolMode = ModeOfOperation::CoolingMode;
         } else {
-            MSHeatPump(MSHeatPumpNum).HeatCoolMode = ModeOfOperation::Invalid;
+            mshp.HeatCoolMode = ModeOfOperation::Invalid;
         }
 
         // Determine the staged status
         if (allocated(state.dataZoneCtrls->StageZoneLogic)) {
             if (state.dataZoneCtrls->StageZoneLogic(ZoneNum)) {
-                MSHeatPump(MSHeatPumpNum).Staged = true;
-                MSHeatPump(MSHeatPumpNum).StageNum = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).StageNum;
+                mshp.Staged = true;
+                mshp.StageNum = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).StageNum;
             } else {
-                if (MSHeatPump(MSHeatPumpNum).MyStagedFlag) {
+                if (mshp.MyStagedFlag) {
                     ShowWarningError(state,
                                      "ZoneControl:Thermostat:StagedDualSetpoint is found, but is not applied to this "
                                      "AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed object = ");
-                    ShowContinueError(state, format("{}. Please make correction. Simulation continues...", MSHeatPump(MSHeatPumpNum).Name));
-                    MSHeatPump(MSHeatPumpNum).MyStagedFlag = false;
+                    ShowContinueError(state, format("{}. Please make correction. Simulation continues...", mshp.Name));
+                    mshp.MyStagedFlag = false;
                 }
             }
         }
         // Set the inlet node mass flow rate
-        if (MSHeatPump(MSHeatPumpNum).fanOp == HVAC::FanOp::Continuous) {
+        if (mshp.fanOp == HVAC::FanOp::Continuous) {
             // constant fan mode
             if (QZnReq > HVAC::SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
-                state.dataHVACMultiSpdHP->CompOnMassFlow = MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(1);
-                state.dataHVACMultiSpdHP->CompOnFlowRatio = MSHeatPump(MSHeatPumpNum).HeatingSpeedRatio(1);
-                MSHeatPump(MSHeatPumpNum).LastMode = ModeOfOperation::HeatingMode;
+                state.dataHVACMultiSpdHP->CompOnMassFlow = mshp.HeatMassFlowRate(1);
+                state.dataHVACMultiSpdHP->CompOnFlowRatio = mshp.HeatingSpeedRatio(1);
+                mshp.LastMode = ModeOfOperation::HeatingMode;
             } else if (QZnReq < (-1.0 * HVAC::SmallLoad) && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
-                state.dataHVACMultiSpdHP->CompOnMassFlow = MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(1);
-                state.dataHVACMultiSpdHP->CompOnFlowRatio = MSHeatPump(MSHeatPumpNum).CoolingSpeedRatio(1);
-                MSHeatPump(MSHeatPumpNum).LastMode = ModeOfOperation::CoolingMode;
+                state.dataHVACMultiSpdHP->CompOnMassFlow = mshp.CoolMassFlowRate(1);
+                state.dataHVACMultiSpdHP->CompOnFlowRatio = mshp.CoolingSpeedRatio(1);
+                mshp.LastMode = ModeOfOperation::CoolingMode;
             } else {
-                state.dataHVACMultiSpdHP->CompOnMassFlow = MSHeatPump(MSHeatPumpNum).IdleMassFlowRate;
-                state.dataHVACMultiSpdHP->CompOnFlowRatio = MSHeatPump(MSHeatPumpNum).IdleSpeedRatio;
+                state.dataHVACMultiSpdHP->CompOnMassFlow = mshp.IdleMassFlowRate;
+                state.dataHVACMultiSpdHP->CompOnFlowRatio = mshp.IdleSpeedRatio;
             }
-            state.dataHVACMultiSpdHP->CompOffMassFlow = MSHeatPump(MSHeatPumpNum).IdleMassFlowRate;
-            state.dataHVACMultiSpdHP->CompOffFlowRatio = MSHeatPump(MSHeatPumpNum).IdleSpeedRatio;
+            state.dataHVACMultiSpdHP->CompOffMassFlow = mshp.IdleMassFlowRate;
+            state.dataHVACMultiSpdHP->CompOffFlowRatio = mshp.IdleSpeedRatio;
         } else {
             // cycling fan mode
             if (QZnReq > HVAC::SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
-                state.dataHVACMultiSpdHP->CompOnMassFlow = MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(1);
-                state.dataHVACMultiSpdHP->CompOnFlowRatio = MSHeatPump(MSHeatPumpNum).HeatingSpeedRatio(1);
+                state.dataHVACMultiSpdHP->CompOnMassFlow = mshp.HeatMassFlowRate(1);
+                state.dataHVACMultiSpdHP->CompOnFlowRatio = mshp.HeatingSpeedRatio(1);
             } else if (QZnReq < (-1.0 * HVAC::SmallLoad) && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
-                state.dataHVACMultiSpdHP->CompOnMassFlow = MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(1);
-                state.dataHVACMultiSpdHP->CompOnFlowRatio = MSHeatPump(MSHeatPumpNum).CoolingSpeedRatio(1);
+                state.dataHVACMultiSpdHP->CompOnMassFlow = mshp.CoolMassFlowRate(1);
+                state.dataHVACMultiSpdHP->CompOnFlowRatio = mshp.CoolingSpeedRatio(1);
             } else {
                 state.dataHVACMultiSpdHP->CompOnMassFlow = 0.0;
                 state.dataHVACMultiSpdHP->CompOnFlowRatio = 0.0;
@@ -2363,13 +2011,13 @@ namespace HVACMultiSpeedHeatPump {
         }
 
         // Set the inlet node mass flow rate
-        if (MSHeatPump(MSHeatPumpNum).availSched->getCurrentVal() > 0.0 && state.dataHVACMultiSpdHP->CompOnMassFlow != 0.0) {
+        if (mshp.availSched->getCurrentVal() > 0.0 && state.dataHVACMultiSpdHP->CompOnMassFlow != 0.0) {
             OnOffAirFlowRatio = 1.0;
             if (FirstHVACIteration) {
-                state.dataLoopNodes->Node(MSHeatPump(MSHeatPumpNum).AirInletNodeNum).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
+                s_node->Node(mshp.AirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
                 PartLoadFrac = 0.0;
             } else {
-                if (MSHeatPump(MSHeatPumpNum).HeatCoolMode != ModeOfOperation::Invalid) {
+                if (mshp.HeatCoolMode != ModeOfOperation::Invalid) {
                     PartLoadFrac = 1.0;
                 } else {
                     PartLoadFrac = 0.0;
@@ -2377,69 +2025,57 @@ namespace HVACMultiSpeedHeatPump {
             }
         } else {
             PartLoadFrac = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(OutNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMaxAvail = 0.0;
+            s_node->Node(mshp.AirInletNode).MassFlowRate = 0.0;
+            s_node->Node(mshp.AirOutletNode).MassFlowRate = 0.0;
+            s_node->Node(mshp.AirOutletNode).MassFlowRateMaxAvail = 0.0;
             OnOffAirFlowRatio = 1.0;
         }
 
         // Check availability of DX coils
-        if (MSHeatPump(MSHeatPumpNum).availSched->getCurrentVal() > 0.0) {
-            if (MSHeatPump(MSHeatPumpNum).HeatCoolMode == ModeOfOperation::CoolingMode) {
-                auto *coilAvailSched = DXCoils::GetDXCoilAvailSched( // TODO: Why isn't this stored on the struct?
-                    state,
-                    "Coil:Cooling:DX:MultiSpeed",
-                    MSHeatPump(MSHeatPumpNum).DXCoolCoilName,
-                    ErrorsFound,
-                    MSHeatPump(MSHeatPumpNum).DXCoolCoilIndex);
-                if (ErrorsFound) {
-                    ShowFatalError(state, "InitMSHeatPump, The previous error causes termination.");
-                }
+        if (mshp.availSched->getCurrentVal() > 0.0) {
+            if (mshp.HeatCoolMode == ModeOfOperation::CoolingMode) {
+                auto *coilAvailSched = DXCoils::GetCoilAvailSched(state, mshp.CoolCoilNum); // TODO: Why isn't this stored on the struct?
                 if (coilAvailSched->getCurrentVal() == 0.0) {
-                    if (MSHeatPump(MSHeatPumpNum).CoolCountAvail == 0) {
-                        ++MSHeatPump(MSHeatPumpNum).CoolCountAvail;
+                    if (mshp.CoolCountAvail == 0) {
+                        ++mshp.CoolCountAvail;
                         ShowWarningError(
                             state,
                             format("{} is ready to perform cooling, but its DX cooling coil = {} is not available at Available Schedule = {}.",
-                                   MSHeatPump(MSHeatPumpNum).Name,
-                                   MSHeatPump(MSHeatPumpNum).DXCoolCoilName,
+                                   mshp.Name,
+                                   mshp.CoolCoilName,
                                    coilAvailSched->Name));
                         ShowContinueErrorTimeStamp(state, format("Availability schedule returned={:.1R}", coilAvailSched->getCurrentVal()));
                     } else {
-                        ++MSHeatPump(MSHeatPumpNum).CoolCountAvail;
+                        ++mshp.CoolCountAvail;
                         ShowRecurringWarningErrorAtEnd(state,
-                                                       MSHeatPump(MSHeatPumpNum).Name + ": Cooling coil is still not available ...",
-                                                       MSHeatPump(MSHeatPumpNum).CoolIndexAvail,
+                                                       mshp.Name + ": Cooling coil is still not available ...",
+                                                       mshp.CoolIndexAvail,
                                                        coilAvailSched->getCurrentVal(),
                                                        coilAvailSched->getCurrentVal());
                     }
                 }
             }
-            if (MSHeatPump(MSHeatPumpNum).HeatCoolMode == ModeOfOperation::HeatingMode &&
-                MSHeatPump(MSHeatPumpNum).HeatCoilType == MultiSpeedHeatingCoil) {
-                auto *coilAvailSched = DXCoils::GetDXCoilAvailSched(state,
-                                                                    "Coil:Heating:DX:MultiSpeed",
-                                                                    MSHeatPump(MSHeatPumpNum).DXHeatCoilName,
-                                                                    ErrorsFound,
-                                                                    MSHeatPump(MSHeatPumpNum).DXHeatCoilIndex);
+            if (mshp.HeatCoolMode == ModeOfOperation::HeatingMode &&
+                mshp.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+                auto *coilAvailSched = DXCoils::GetCoilAvailSched(state, mshp.HeatCoilNum);
                 if (ErrorsFound) {
                     ShowFatalError(state, "InitMSHeatPump, The previous error causes termination.");
                 }
                 if (coilAvailSched->getCurrentVal() == 0.0) {
-                    if (MSHeatPump(MSHeatPumpNum).HeatCountAvail == 0) {
-                        ++MSHeatPump(MSHeatPumpNum).HeatCountAvail;
+                    if (mshp.HeatCountAvail == 0) {
+                        ++mshp.HeatCountAvail;
                         ShowWarningError(
                             state,
                             format("{} is ready to perform heating, but its DX heating coil = {} is not available at Available Schedule = {}.",
-                                   MSHeatPump(MSHeatPumpNum).Name,
-                                   MSHeatPump(MSHeatPumpNum).DXCoolCoilName,
+                                   mshp.Name,
+                                   mshp.CoolCoilName,
                                    coilAvailSched->Name));
                         ShowContinueErrorTimeStamp(state, format("Availability schedule returned={:.1R}", coilAvailSched->getCurrentVal()));
                     } else {
-                        ++MSHeatPump(MSHeatPumpNum).HeatCountAvail;
+                        ++mshp.HeatCountAvail;
                         ShowRecurringWarningErrorAtEnd(state,
-                                                       MSHeatPump(MSHeatPumpNum).Name + ": Heating coil is still not available ...",
-                                                       MSHeatPump(MSHeatPumpNum).HeatIndexAvail,
+                                                       mshp.Name + ": Heating coil is still not available ...",
+                                                       mshp.HeatIndexAvail,
                                                        coilAvailSched->getCurrentVal(),
                                                        coilAvailSched->getCurrentVal());
                     }
@@ -2463,42 +2099,40 @@ namespace HVACMultiSpeedHeatPump {
                        OnOffAirFlowRatio,
                        state.dataHVACMultiSpdHP->SupHeaterLoad);
 
-        auto &e = MSHeatPump(MSHeatPumpNum);
-        {
-            e.TotHeatEnergyRate = 0.0;
-            e.SensHeatEnergyRate = 0.0;
-            e.LatHeatEnergyRate = 0.0;
-            e.TotCoolEnergyRate = 0.0;
-            e.SensCoolEnergyRate = 0.0;
-            e.LatCoolEnergyRate = 0.0;
-        }
+        mshp.TotHeatEnergyRate = 0.0;
+        mshp.SensHeatEnergyRate = 0.0;
+        mshp.LatHeatEnergyRate = 0.0;
+        mshp.TotCoolEnergyRate = 0.0;
+        mshp.SensCoolEnergyRate = 0.0;
+        mshp.LatCoolEnergyRate = 0.0;
+
         // If unit is scheduled OFF, setpoint is equal to inlet node temperature.
         //!!LKL Discrepancy with < 0
-        if (MSHeatPump(MSHeatPumpNum).availSched->getCurrentVal() == 0.0) {
-            state.dataLoopNodes->Node(OutNode).Temp = state.dataLoopNodes->Node(InNode).Temp;
+        if (mshp.availSched->getCurrentVal() == 0.0) {
+            s_node->Node(mshp.AirOutletNode).Temp = s_node->Node(mshp.AirInletNode).Temp;
             return;
         }
 
-        if ((MSHeatPump(MSHeatPumpNum).HeatCoolMode == ModeOfOperation::Invalid && MSHeatPump(MSHeatPumpNum).fanOp == HVAC::FanOp::Cycling) ||
+        if ((mshp.HeatCoolMode == ModeOfOperation::Invalid && mshp.fanOp == HVAC::FanOp::Cycling) ||
             state.dataHVACMultiSpdHP->CompOnMassFlow == 0.0) {
             QZnReq = 0.0;
             PartLoadFrac = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMaxAvail = 0.0;
+            s_node->Node(mshp.AirInletNode).MassFlowRate = 0.0;
+            s_node->Node(mshp.AirOutletNode).MassFlowRateMaxAvail = 0.0;
         }
-        MSHeatPump(MSHeatPumpNum).LoadMet = 0.0;
+        mshp.LoadMet = 0.0;
         SetAverageAirFlow(state, MSHeatPumpNum, PartLoadFrac, OnOffAirFlowRatio);
 
         // Init maximum available Heat Recovery flow rate
-        if ((MSHeatPump(MSHeatPumpNum).HeatRecActive) && (!MSHeatPump(MSHeatPumpNum).MyPlantScantFlag)) {
+        if ((mshp.HeatRecActive) && (!mshp.MyPlantScantFlag)) {
             if (PartLoadFrac > 0.0) {
                 if (FirstHVACIteration) {
-                    MdotHR = MSHeatPump(MSHeatPumpNum).DesignHeatRecMassFlowRate;
+                    MdotHR = mshp.DesignHeatRecMassFlowRate;
                 } else {
-                    if (MSHeatPump(MSHeatPumpNum).HeatRecoveryMassFlowRate > 0.0) {
-                        MdotHR = MSHeatPump(MSHeatPumpNum).HeatRecoveryMassFlowRate;
+                    if (mshp.HeatRecoveryMassFlowRate > 0.0) {
+                        MdotHR = mshp.HeatRecoveryMassFlowRate;
                     } else {
-                        MdotHR = MSHeatPump(MSHeatPumpNum).DesignHeatRecMassFlowRate;
+                        MdotHR = mshp.DesignHeatRecMassFlowRate;
                     }
                 }
             } else {
@@ -2507,83 +2141,78 @@ namespace HVACMultiSpeedHeatPump {
 
             PlantUtilities::SetComponentFlowRate(state,
                                                  MdotHR,
-                                                 MSHeatPump(MSHeatPumpNum).HeatRecInletNodeNum,
-                                                 MSHeatPump(MSHeatPumpNum).HeatRecOutletNodeNum,
-                                                 MSHeatPump(MSHeatPumpNum).HRPlantLoc);
+                                                 mshp.HeatRecFluidInletNode,
+                                                 mshp.HeatRecFluidOutletNode,
+                                                 mshp.HRPlantLoc);
         }
 
         // get operating capacity of water and steam coil
         if (FirstHVACIteration) {
-            if (MSHeatPump(MSHeatPumpNum).HeatCoilType == HVAC::Coil_HeatingWater) {
+            if (mshp.heatCoilType == HVAC::CoilType::HeatingWater) {
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(MSHeatPump(MSHeatPumpNum).CoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
-                mdot = MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow;
+                s_node->Node(mshp.HeatCoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
+                mdot = mshp.HeatCoilMaxFluidFlow;
                 PlantUtilities::SetComponentFlowRate(state,
                                                      mdot,
-                                                     MSHeatPump(MSHeatPumpNum).CoilControlNode,
-                                                     MSHeatPump(MSHeatPumpNum).CoilOutletNode,
-                                                     MSHeatPump(MSHeatPumpNum).plantLoc);
+                                                     mshp.HeatCoilControlNode,
+                                                     mshp.HeatCoilFluidOutletNode,
+                                                     mshp.HeatCoilPlantLoc);
                 //     simulate water coil to find operating capacity
-                WaterCoils::SimulateWaterCoilComponents(
-                    state, MSHeatPump(MSHeatPumpNum).HeatCoilName, FirstHVACIteration, MSHeatPump(MSHeatPumpNum).HeatCoilNum, QActual);
-            } // from IF(MSHeatPump(MSHeatPumpNum)%HeatCoilType == Coil_HeatingWater) THEN
+                WaterCoils::SimulateWaterCoilComponents(state, mshp.HeatCoilName, FirstHVACIteration, mshp.HeatCoilNum, QActual);
 
-            if (MSHeatPump(MSHeatPumpNum).HeatCoilType == HVAC::Coil_HeatingSteam) {
+            } else if (mshp.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(MSHeatPump(MSHeatPumpNum).CoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
-                mdot = MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow;
+                s_node->Node(mshp.HeatCoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
+                mdot = mshp.HeatCoilMaxFluidFlow;
                 PlantUtilities::SetComponentFlowRate(state,
                                                      mdot,
-                                                     MSHeatPump(MSHeatPumpNum).CoilControlNode,
-                                                     MSHeatPump(MSHeatPumpNum).CoilOutletNode,
-                                                     MSHeatPump(MSHeatPumpNum).plantLoc);
+                                                     mshp.HeatCoilControlNode,
+                                                     mshp.HeatCoilFluidOutletNode,
+                                                     mshp.HeatCoilPlantLoc);
 
                 //     simulate steam coil to find operating capacity
                 SteamCoils::SimulateSteamCoilComponents(state,
-                                                        MSHeatPump(MSHeatPumpNum).HeatCoilName,
+                                                        mshp.HeatCoilName,
                                                         FirstHVACIteration,
-                                                        MSHeatPump(MSHeatPumpNum).HeatCoilNum,
+                                                        mshp.HeatCoilNum,
                                                         1.0,
                                                         QActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
 
-            } // from IF(MSHeatPump(MSHeatPumpNum)%HeatCoilType == Coil_HeatingSteam) THEN
-            if (MSHeatPump(MSHeatPumpNum).SuppHeatCoilType == HVAC::Coil_HeatingWater) {
+            }
+            
+            if (mshp.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(MSHeatPump(MSHeatPumpNum).SuppCoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
-                mdot = MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow;
+                s_node->Node(mshp.SuppHeatCoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
+                mdot = mshp.SuppHeatCoilMaxFluidFlow;
                 PlantUtilities::SetComponentFlowRate(state,
                                                      mdot,
-                                                     MSHeatPump(MSHeatPumpNum).SuppCoilControlNode,
-                                                     MSHeatPump(MSHeatPumpNum).SuppCoilOutletNode,
-                                                     MSHeatPump(MSHeatPumpNum).SuppPlantLoc);
+                                                     mshp.SuppHeatCoilControlNode,
+                                                     mshp.SuppHeatCoilFluidOutletNode,
+                                                     mshp.SuppHeatCoilPlantLoc);
                 //     simulate water coil to find operating capacity
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, FirstHVACIteration, MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum, QActual);
-                MSHeatPump(MSHeatPumpNum).DesignSuppHeatingCapacity = QActual;
-
-            } // from IF(MSHeatPump(MSHeatPumpNum)%SuppHeatCoilType == Coil_HeatingWater) THEN
+                    state, mshp.SuppHeatCoilName, FirstHVACIteration, mshp.SuppHeatCoilNum, QActual);
+                mshp.DesignSuppHeatingCapacity = QActual;
 
-            if (MSHeatPump(MSHeatPumpNum).SuppHeatCoilType == HVAC::Coil_HeatingSteam) {
+            } else if (mshp.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
 
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(MSHeatPump(MSHeatPumpNum).SuppCoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
-                mdot = MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow;
+                s_node->Node(mshp.SuppHeatCoilAirInletNode).MassFlowRate = state.dataHVACMultiSpdHP->CompOnMassFlow;
+                mdot = mshp.SuppHeatCoilMaxFluidFlow;
                 PlantUtilities::SetComponentFlowRate(state,
                                                      mdot,
-                                                     MSHeatPump(MSHeatPumpNum).SuppCoilControlNode,
-                                                     MSHeatPump(MSHeatPumpNum).SuppCoilOutletNode,
-                                                     MSHeatPump(MSHeatPumpNum).SuppPlantLoc);
+                                                     mshp.SuppHeatCoilControlNode,
+                                                     mshp.SuppHeatCoilFluidOutletNode,
+                                                     mshp.SuppHeatCoilPlantLoc);
 
                 //     simulate steam coil to find operating capacity
                 SteamCoils::SimulateSteamCoilComponents(state,
-                                                        MSHeatPump(MSHeatPumpNum).SuppHeatCoilName,
+                                                        mshp.SuppHeatCoilNum,
                                                         FirstHVACIteration,
-                                                        MSHeatPump(MSHeatPumpNum).SuppHeatCoilNum,
                                                         1.0,
                                                         QActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                MSHeatPump(MSHeatPumpNum).DesignSuppHeatingCapacity =
-                    SteamCoils::GetCoilCapacity(state, "Coil:Heating:Steam", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound);
+                mshp.DesignSuppHeatingCapacity = SteamCoils::GetCoilCapacity(state, mshp.SuppHeatCoilNum);
 
             } // from IF(MSHeatPump(MSHeatPumpNum)%SuppHeatCoilType == Coil_HeatingSteam) THEN
         }     // from IF( FirstHVACIteration ) THEN
@@ -2600,31 +2229,23 @@ namespace HVACMultiSpeedHeatPump {
         // PURPOSE OF THIS SUBROUTINE:
         // This subroutine is for sizing multispeed heat pump airflow rates and flow fraction.
 
-        // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        int NumOfSpeedCooling; // Number of speeds for cooling
-        int NumOfSpeedHeating; // Number of speeds for heating
-        int i;                 // Index to speed
-
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
         if (state.dataSize->CurSysNum > 0 && state.dataSize->CurOASysNum == 0) {
-            state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum = MSHeatPump.FanNum;
-            state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanType = MSHeatPump.fanType;
-            state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace = MSHeatPump.fanPlace;
+            state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum = mshp.FanNum;
+            state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanType = mshp.fanType;
+            state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace = mshp.fanPlace;
         }
 
-        NumOfSpeedCooling = MSHeatPump.NumOfSpeedCooling;
-        NumOfSpeedHeating = MSHeatPump.NumOfSpeedHeating;
+        for (int i = mshp.NumOfSpeedCooling; i >= 1; --i) {
 
-        for (i = NumOfSpeedCooling; i >= 1; --i) {
-
-            if (MSHeatPump.CoolVolumeFlowRate(i) == DataSizing::AutoSize) {
+            if (mshp.CoolVolumeFlowRate(i) == DataSizing::AutoSize) {
                 if (state.dataSize->CurSysNum > 0) {
-                    if (i == NumOfSpeedCooling) {
-                        CheckSysSizing(state, state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump.Name);
-                        MSHeatPump.CoolVolumeFlowRate(i) = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
-                        if (MSHeatPump.FanVolFlow < MSHeatPump.CoolVolumeFlowRate(i) && MSHeatPump.FanVolFlow != DataSizing::AutoSize) {
-                            MSHeatPump.CoolVolumeFlowRate(i) = MSHeatPump.FanVolFlow;
-                            ShowWarningError(state, format("{} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump.Name));
+                    if (i == mshp.NumOfSpeedCooling) {
+                        CheckSysSizing(state, state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name);
+                        mshp.CoolVolumeFlowRate(i) = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
+                        if (mshp.FanVolFlow < mshp.CoolVolumeFlowRate(i) && mshp.FanVolFlow != DataSizing::AutoSize) {
+                            mshp.CoolVolumeFlowRate(i) = mshp.FanVolFlow;
+                            ShowWarningError(state, format("{} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
                             ShowContinueError(state,
                                               "The supply air flow rate at high speed is less than the autosized value for the supply air flow rate "
                                               "in cooling mode. Consider autosizing the fan for this simulation.");
@@ -2633,35 +2254,35 @@ namespace HVACMultiSpeedHeatPump {
                                 "The air flow rate at high speed in cooling mode is reset to the supply air flow rate and the simulation continues.");
                         }
                     } else {
-                        MSHeatPump.CoolVolumeFlowRate(i) = MSHeatPump.CoolVolumeFlowRate(NumOfSpeedCooling) * i / NumOfSpeedCooling;
+                        mshp.CoolVolumeFlowRate(i) = mshp.CoolVolumeFlowRate(mshp.NumOfSpeedCooling) * i / mshp.NumOfSpeedCooling;
                     }
-                    if (MSHeatPump.CoolVolumeFlowRate(i) < HVAC::SmallAirVolFlow) {
-                        MSHeatPump.CoolVolumeFlowRate = 0.0;
+                    if (mshp.CoolVolumeFlowRate(i) < HVAC::SmallAirVolFlow) {
+                        mshp.CoolVolumeFlowRate = 0.0;
                     }
                     // Ensure the flow rate at lower speed has to be less or equal to the flow rate at higher speed
-                    if (i != NumOfSpeedCooling) {
-                        if (MSHeatPump.CoolVolumeFlowRate(i) > MSHeatPump.CoolVolumeFlowRate(i + 1)) {
-                            MSHeatPump.CoolVolumeFlowRate(i) = MSHeatPump.CoolVolumeFlowRate(i + 1);
+                    if (i != mshp.NumOfSpeedCooling) {
+                        if (mshp.CoolVolumeFlowRate(i) > mshp.CoolVolumeFlowRate(i + 1)) {
+                            mshp.CoolVolumeFlowRate(i) = mshp.CoolVolumeFlowRate(i + 1);
                         }
                     }
                     BaseSizer::reportSizerOutput(state,
                                                  state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                                 MSHeatPump.Name,
+                                                 mshp.Name,
                                                  format("Speed {} Supply Air Flow Rate During Cooling Operation [m3/s]", i),
-                                                 MSHeatPump.CoolVolumeFlowRate(i));
+                                                 mshp.CoolVolumeFlowRate(i));
                 }
             }
         }
 
-        for (i = NumOfSpeedHeating; i >= 1; --i) {
-            if (MSHeatPump.HeatVolumeFlowRate(i) == DataSizing::AutoSize) {
+        for (int i = mshp.NumOfSpeedHeating; i >= 1; --i) {
+            if (mshp.HeatVolumeFlowRate(i) == DataSizing::AutoSize) {
                 if (state.dataSize->CurSysNum > 0) {
-                    if (i == NumOfSpeedHeating) {
-                        CheckSysSizing(state, state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump.Name);
-                        MSHeatPump.HeatVolumeFlowRate(i) = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
-                        if (MSHeatPump.FanVolFlow < MSHeatPump.HeatVolumeFlowRate(i) && MSHeatPump.FanVolFlow != DataSizing::AutoSize) {
-                            MSHeatPump.HeatVolumeFlowRate(i) = MSHeatPump.FanVolFlow;
-                            ShowWarningError(state, format("{} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump.Name));
+                    if (i == mshp.NumOfSpeedHeating) {
+                        CheckSysSizing(state, state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name);
+                        mshp.HeatVolumeFlowRate(i) = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
+                        if (mshp.FanVolFlow < mshp.HeatVolumeFlowRate(i) && mshp.FanVolFlow != DataSizing::AutoSize) {
+                            mshp.HeatVolumeFlowRate(i) = mshp.FanVolFlow;
+                            ShowWarningError(state, format("{} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
                             ShowContinueError(state,
                                               "The supply air flow rate at high speed is less than the autosized value for the maximum air flow rate "
                                               "in heating mode. Consider autosizing the fan for this simulation.");
@@ -2670,33 +2291,33 @@ namespace HVACMultiSpeedHeatPump {
                                               "simulation continues.");
                         }
                     } else {
-                        MSHeatPump.HeatVolumeFlowRate(i) = MSHeatPump.HeatVolumeFlowRate(NumOfSpeedHeating) * i / NumOfSpeedHeating;
+                        mshp.HeatVolumeFlowRate(i) = mshp.HeatVolumeFlowRate(mshp.NumOfSpeedHeating) * i / mshp.NumOfSpeedHeating;
                     }
-                    if (MSHeatPump.HeatVolumeFlowRate(i) < HVAC::SmallAirVolFlow) {
-                        MSHeatPump.HeatVolumeFlowRate(i) = 0.0;
+                    if (mshp.HeatVolumeFlowRate(i) < HVAC::SmallAirVolFlow) {
+                        mshp.HeatVolumeFlowRate(i) = 0.0;
                     }
                     // Ensure the flow rate at lower speed has to be less or equal to the flow rate at higher speed
-                    if (i != NumOfSpeedHeating) {
-                        if (MSHeatPump.HeatVolumeFlowRate(i) > MSHeatPump.HeatVolumeFlowRate(i + 1)) {
-                            MSHeatPump.HeatVolumeFlowRate(i) = MSHeatPump.HeatVolumeFlowRate(i + 1);
+                    if (i != mshp.NumOfSpeedHeating) {
+                        if (mshp.HeatVolumeFlowRate(i) > mshp.HeatVolumeFlowRate(i + 1)) {
+                            mshp.HeatVolumeFlowRate(i) = mshp.HeatVolumeFlowRate(i + 1);
                         }
                     }
                     BaseSizer::reportSizerOutput(state,
                                                  state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                                 MSHeatPump.Name,
+                                                 mshp.Name,
                                                  format("Speed{}Supply Air Flow Rate During Heating Operation [m3/s]", i),
-                                                 MSHeatPump.HeatVolumeFlowRate(i));
+                                                 mshp.HeatVolumeFlowRate(i));
                 }
             }
         }
 
-        if (MSHeatPump.IdleVolumeAirRate == DataSizing::AutoSize) {
+        if (mshp.IdleVolumeAirRate == DataSizing::AutoSize) {
             if (state.dataSize->CurSysNum > 0) {
-                CheckSysSizing(state, state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump.Name);
-                MSHeatPump.IdleVolumeAirRate = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
-                if (MSHeatPump.FanVolFlow < MSHeatPump.IdleVolumeAirRate && MSHeatPump.FanVolFlow != DataSizing::AutoSize) {
-                    MSHeatPump.IdleVolumeAirRate = MSHeatPump.FanVolFlow;
-                    ShowWarningError(state, format("{} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, MSHeatPump.Name));
+                CheckSysSizing(state, state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name);
+                mshp.IdleVolumeAirRate = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
+                if (mshp.FanVolFlow < mshp.IdleVolumeAirRate && mshp.FanVolFlow != DataSizing::AutoSize) {
+                    mshp.IdleVolumeAirRate = mshp.FanVolFlow;
+                    ShowWarningError(state, format("{} \"{}\"", state.dataHVACMultiSpdHP->CurrentModuleObject, mshp.Name));
                     ShowContinueError(state,
                                       "The supply air flow rate is less than the autosized value for the maximum air flow rate when no heating or "
                                       "cooling is needed. Consider autosizing the fan for this simulation.");
@@ -2704,55 +2325,48 @@ namespace HVACMultiSpeedHeatPump {
                                       "The maximum air flow rate when no heating or cooling is needed is reset to the supply air flow rate and the "
                                       "simulation continues.");
                 }
-                if (MSHeatPump.IdleVolumeAirRate < HVAC::SmallAirVolFlow) {
-                    MSHeatPump.IdleVolumeAirRate = 0.0;
+                if (mshp.IdleVolumeAirRate < HVAC::SmallAirVolFlow) {
+                    mshp.IdleVolumeAirRate = 0.0;
                 }
 
                 BaseSizer::reportSizerOutput(state,
                                              state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                             MSHeatPump.Name,
+                                             mshp.Name,
                                              "Supply Air Flow Rate When No Cooling or Heating is Needed [m3/s]",
-                                             MSHeatPump.IdleVolumeAirRate);
+                                             mshp.IdleVolumeAirRate);
             }
         }
 
-        if (MSHeatPump.SuppMaxAirTemp == DataSizing::AutoSize) {
+        if (mshp.SuppMaxAirTemp == DataSizing::AutoSize) {
             if (state.dataSize->CurSysNum > 0) {
-                if (MSHeatPump.SuppHeatCoilType == 1) { // Gas
-                    CheckZoneSizing(state, "Coil:Heating:Fuel", MSHeatPump.Name);
-                } else {
-                    CheckZoneSizing(state, "Coil:Heating:Electric", MSHeatPump.Name);
-                }
-                MSHeatPump.SuppMaxAirTemp = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatSupTemp;
+                CheckZoneSizing(state, HVAC::coilTypeNames[(int)mshp.suppHeatCoilType], mshp.Name);
+
+                mshp.SuppMaxAirTemp = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatSupTemp;
                 BaseSizer::reportSizerOutput(state,
                                              state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                             MSHeatPump.Name,
+                                             mshp.Name,
                                              "Maximum Supply Air Temperature from Supplemental Heater [C]",
-                                             MSHeatPump.SuppMaxAirTemp);
+                                             mshp.SuppMaxAirTemp);
             }
         }
 
-        if (MSHeatPump.DesignSuppHeatingCapacity == DataSizing::AutoSize) {
+        if (mshp.DesignSuppHeatingCapacity == DataSizing::AutoSize) {
             if (state.dataSize->CurSysNum > 0) {
-                if (MSHeatPump.SuppHeatCoilType == 1) { // Gas
-                    CheckSysSizing(state, "Coil:Heating:Fuel", MSHeatPump.Name);
-                } else {
-                    CheckSysSizing(state, "Coil:Heating:Electric", MSHeatPump.Name);
-                }
-                MSHeatPump.DesignSuppHeatingCapacity = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatCap;
+                CheckSysSizing(state, HVAC::coilTypeNames[(int)mshp.suppHeatCoilType], mshp.Name);
+                mshp.DesignSuppHeatingCapacity = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).HeatCap;
             } else {
-                MSHeatPump.DesignSuppHeatingCapacity = 0.0;
+                mshp.DesignSuppHeatingCapacity = 0.0;
             }
             BaseSizer::reportSizerOutput(state,
                                          state.dataHVACMultiSpdHP->CurrentModuleObject,
-                                         MSHeatPump.Name,
+                                         mshp.Name,
                                          "Supplemental Heating Coil Nominal Capacity [W]",
-                                         MSHeatPump.DesignSuppHeatingCapacity);
+                                         mshp.DesignSuppHeatingCapacity);
         }
-        state.dataSize->SuppHeatCap = MSHeatPump.DesignSuppHeatingCapacity;
+        state.dataSize->SuppHeatCap = mshp.DesignSuppHeatingCapacity;
 
-        if (MSHeatPump.HeatRecActive) {
-            PlantUtilities::RegisterPlantCompDesignFlow(state, MSHeatPump.HeatRecInletNodeNum, MSHeatPump.DesignHeatRecFlowRate);
+        if (mshp.HeatRecActive) {
+            PlantUtilities::RegisterPlantCompDesignFlow(state, mshp.HeatRecFluidInletNode, mshp.DesignHeatRecFlowRate);
         }
     }
 
@@ -2776,31 +2390,31 @@ namespace HVACMultiSpeedHeatPump {
         OnOffAirFlowRatio = 0.0;
         SupHeaterLoad = 0.0;
 
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
 
         // Get EMS output
         SpeedNum = ceil(SpeedVal);
         bool useMaxedSpeed = false;
         std::string useMaxedSpeedCoilName;
-        if (MSHeatPump.HeatCoolMode == ModeOfOperation::HeatingMode) {
-            if (SpeedNum > MSHeatPump.NumOfSpeedHeating) {
-                SpeedNum = MSHeatPump.NumOfSpeedHeating;
+        if (mshp.HeatCoolMode == ModeOfOperation::HeatingMode) {
+            if (SpeedNum > mshp.NumOfSpeedHeating) {
+                SpeedNum = mshp.NumOfSpeedHeating;
                 useMaxedSpeed = true;
-                useMaxedSpeedCoilName = MSHeatPump.DXHeatCoilName;
+                useMaxedSpeedCoilName = mshp.HeatCoilName;
             }
-        } else if (MSHeatPump.HeatCoolMode == ModeOfOperation::CoolingMode) {
-            if (SpeedNum > MSHeatPump.NumOfSpeedCooling) {
-                SpeedNum = MSHeatPump.NumOfSpeedCooling;
+        } else if (mshp.HeatCoolMode == ModeOfOperation::CoolingMode) {
+            if (SpeedNum > mshp.NumOfSpeedCooling) {
+                SpeedNum = mshp.NumOfSpeedCooling;
                 useMaxedSpeed = true;
-                useMaxedSpeedCoilName = MSHeatPump.DXCoolCoilName;
+                useMaxedSpeedCoilName = mshp.CoolCoilName;
             }
         }
         if (useMaxedSpeed) {
-            MSHeatPump.CoilSpeedErrIndex++;
+            mshp.CoilSpeedErrIndex++;
             ShowRecurringWarningErrorAtEnd(state,
                                            "Wrong coil speed EMS override value, for unit=\"" + useMaxedSpeedCoilName +
                                                "\". Exceeding maximum coil speed level. Speed level is set to the maximum coil speed level allowed.",
-                                           MSHeatPump.CoilSpeedErrIndex,
+                                           mshp.CoilSpeedErrIndex,
                                            SpeedVal,
                                            SpeedVal,
                                            _,
@@ -2883,11 +2497,12 @@ namespace HVACMultiSpeedHeatPump {
         // if the DX heating coil cannot meet the load, trim with supplemental heater
         // occurs with constant fan mode when compressor is on or off
         // occurs with cycling fan mode when compressor PLR is equal to 1
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &s_node = state.dataLoopNodes;
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
 
         if ((QZnReq > HVAC::SmallLoad && QZnReq > EMSOutput)) {
             Real64 TempOutput;
-            if (state.dataEnvrn->OutDryBulbTemp <= MSHeatPump.SuppMaxAirTemp) {
+            if (state.dataEnvrn->OutDryBulbTemp <= mshp.SuppMaxAirTemp) {
                 SupHeaterLoad = QZnReq - EMSOutput;
             } else {
                 SupHeaterLoad = 0.0;
@@ -2906,7 +2521,7 @@ namespace HVACMultiSpeedHeatPump {
         }
 
         // check the outlet of the supplemental heater to be lower than the maximum supplemental heater supply air temperature
-        if (state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).Temp > MSHeatPump.SuppMaxAirTemp && SupHeaterLoad > 0.0) {
+        if (s_node->Node(mshp.AirOutletNode).Temp > mshp.SuppMaxAirTemp && SupHeaterLoad > 0.0) {
 
             //   If the supply air temperature is to high, turn off the supplemental heater to recalculate the outlet temperature
             SupHeaterLoad = 0.0;
@@ -2917,10 +2532,10 @@ namespace HVACMultiSpeedHeatPump {
             //   the supplemental heater, otherwise leave the supplemental heater off. If the supplemental heater is to be turned on,
             //   use the outlet conditions when the supplemental heater was off (CALL above) as the inlet conditions for the calculation
             //   of supplemental heater load to just meet the maximum supply air temperature from the supplemental heater.
-            if (state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).Temp < MSHeatPump.SuppMaxAirTemp) {
-                Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).HumRat);
-                SupHeaterLoad = state.dataLoopNodes->Node(MSHeatPump.AirInletNodeNum).MassFlowRate * CpAir *
-                                (MSHeatPump.SuppMaxAirTemp - state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).Temp);
+            if (s_node->Node(mshp.AirOutletNode).Temp < mshp.SuppMaxAirTemp) {
+                Real64 CpAir = Psychrometrics::PsyCpAirFnW(s_node->Node(mshp.AirOutletNode).HumRat);
+                SupHeaterLoad = s_node->Node(mshp.AirInletNode).MassFlowRate * CpAir *
+                                (mshp.SuppMaxAirTemp - s_node->Node(mshp.AirOutletNode).Temp);
 
             } else {
                 SupHeaterLoad = 0.0;
@@ -2976,10 +2591,12 @@ namespace HVACMultiSpeedHeatPump {
 
         OutsideDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
 
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &s_node = state.dataLoopNodes;
+        
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
 
         //!!LKL Discrepancy with < 0
-        if (MSHeatPump.availSched->getCurrentVal() == 0.0) return;
+        if (mshp.availSched->getCurrentVal() == 0.0) return;
 
         // Get result when DX coil is off
         CalcMSHeatPump(state,
@@ -3004,17 +2621,17 @@ namespace HVACMultiSpeedHeatPump {
         // Get full load result
         PartLoadFrac = 1.0;
         SpeedRatio = 1.0;
-        if (MSHeatPump.HeatCoolMode == ModeOfOperation::HeatingMode) {
-            SpeedNum = MSHeatPump.NumOfSpeedHeating;
-            if (MSHeatPump.Staged && std::abs(MSHeatPump.StageNum) < SpeedNum) {
-                SpeedNum = std::abs(MSHeatPump.StageNum);
+        if (mshp.HeatCoolMode == ModeOfOperation::HeatingMode) {
+            SpeedNum = mshp.NumOfSpeedHeating;
+            if (mshp.Staged && std::abs(mshp.StageNum) < SpeedNum) {
+                SpeedNum = std::abs(mshp.StageNum);
                 if (SpeedNum == 1) SpeedRatio = 0.0;
             }
         }
-        if (MSHeatPump.HeatCoolMode == ModeOfOperation::CoolingMode) {
-            SpeedNum = MSHeatPump.NumOfSpeedCooling;
-            if (MSHeatPump.Staged && std::abs(MSHeatPump.StageNum) < SpeedNum) {
-                SpeedNum = std::abs(MSHeatPump.StageNum);
+        if (mshp.HeatCoolMode == ModeOfOperation::CoolingMode) {
+            SpeedNum = mshp.NumOfSpeedCooling;
+            if (mshp.Staged && std::abs(mshp.StageNum) < SpeedNum) {
+                SpeedNum = std::abs(mshp.StageNum);
                 if (SpeedNum == 1) SpeedRatio = 0.0;
             }
         }
@@ -3044,7 +2661,7 @@ namespace HVACMultiSpeedHeatPump {
             if (QZnReq <= FullOutput) {
                 PartLoadFrac = 1.0;
                 SpeedRatio = 1.0;
-                if (MSHeatPump.Staged && SpeedNum == 1) SpeedRatio = 0.0;
+                if (mshp.Staged && SpeedNum == 1) SpeedRatio = 0.0;
                 state.dataHVACMultiSpdHP->MSHeatPumpReport(MSHeatPumpNum).CycRatio = PartLoadFrac;
                 state.dataHVACMultiSpdHP->MSHeatPumpReport(MSHeatPumpNum).SpeedRatio = SpeedRatio;
                 state.dataHVACMultiSpdHP->MSHeatPumpReport(MSHeatPumpNum).SpeedNum = SpeedNum;
@@ -3068,16 +2685,16 @@ namespace HVACMultiSpeedHeatPump {
         }
 
         // Direct solution
-        if (state.dataGlobal->DoCoilDirectSolutions && !MSHeatPump.Staged) {
+        if (state.dataGlobal->DoCoilDirectSolutions && !mshp.Staged) {
             Real64 TempOutput0 = 0.0;
-            MSHeatPump.FullOutput = 0.0;
+            mshp.FullOutput = 0.0;
 
             // heating
             if (QZnReq > HVAC::SmallLoad && QZnReq < FullOutput) {
                 CalcMSHeatPump(
                     state, MSHeatPumpNum, FirstHVACIteration, compressorOp, 1, 0.0, 0.0, TempOutput0, QZnReq, OnOffAirFlowRatio, SupHeaterLoad);
 
-                for (int k = 1; k <= MSHeatPump.NumOfSpeedHeating; ++k) {
+                for (int k = 1; k <= mshp.NumOfSpeedHeating; ++k) {
                     if (k == 1) {
                         CalcMSHeatPump(state,
                                        MSHeatPumpNum,
@@ -3086,13 +2703,13 @@ namespace HVACMultiSpeedHeatPump {
                                        k,
                                        0.0,
                                        1.0,
-                                       MSHeatPump.FullOutput(k),
+                                       mshp.FullOutput(k),
                                        QZnReq,
                                        OnOffAirFlowRatio,
                                        SupHeaterLoad);
-                        if (QZnReq <= MSHeatPump.FullOutput(k)) {
+                        if (QZnReq <= mshp.FullOutput(k)) {
                             SpeedNum = k;
-                            PartLoadFrac = (QZnReq - TempOutput0) / (MSHeatPump.FullOutput(k) - TempOutput0);
+                            PartLoadFrac = (QZnReq - TempOutput0) / (mshp.FullOutput(k) - TempOutput0);
                             CalcMSHeatPump(state,
                                            MSHeatPumpNum,
                                            FirstHVACIteration,
@@ -3114,14 +2731,14 @@ namespace HVACMultiSpeedHeatPump {
                                        k,
                                        1.0,
                                        1.0,
-                                       MSHeatPump.FullOutput(k),
+                                       mshp.FullOutput(k),
                                        QZnReq,
                                        OnOffAirFlowRatio,
                                        SupHeaterLoad);
-                        if (QZnReq <= MSHeatPump.FullOutput(k)) {
+                        if (QZnReq <= mshp.FullOutput(k)) {
                             SpeedNum = k;
                             PartLoadFrac = 1.0;
-                            SpeedRatio = (QZnReq - MSHeatPump.FullOutput(k - 1)) / (MSHeatPump.FullOutput(k) - MSHeatPump.FullOutput(k - 1));
+                            SpeedRatio = (QZnReq - mshp.FullOutput(k - 1)) / (mshp.FullOutput(k) - mshp.FullOutput(k - 1));
                             CalcMSHeatPump(state,
                                            MSHeatPumpNum,
                                            FirstHVACIteration,
@@ -3143,7 +2760,7 @@ namespace HVACMultiSpeedHeatPump {
             if (QZnReq < (-1.0 * HVAC::SmallLoad) && QZnReq > FullOutput) {
                 CalcMSHeatPump(
                     state, MSHeatPumpNum, FirstHVACIteration, compressorOp, 1, 0.0, 0.0, TempOutput0, QZnReq, OnOffAirFlowRatio, SupHeaterLoad);
-                for (int k = 1; k <= MSHeatPump.NumOfSpeedCooling; ++k) {
+                for (int k = 1; k <= mshp.NumOfSpeedCooling; ++k) {
                     if (k == 1) {
                         CalcMSHeatPump(state,
                                        MSHeatPumpNum,
@@ -3152,13 +2769,13 @@ namespace HVACMultiSpeedHeatPump {
                                        k,
                                        0.0,
                                        1.0,
-                                       MSHeatPump.FullOutput(k),
+                                       mshp.FullOutput(k),
                                        QZnReq,
                                        OnOffAirFlowRatio,
                                        SupHeaterLoad);
-                        if (QZnReq >= MSHeatPump.FullOutput(k)) {
+                        if (QZnReq >= mshp.FullOutput(k)) {
                             SpeedNum = k;
-                            PartLoadFrac = (QZnReq - TempOutput0) / (MSHeatPump.FullOutput(k) - TempOutput0);
+                            PartLoadFrac = (QZnReq - TempOutput0) / (mshp.FullOutput(k) - TempOutput0);
                             CalcMSHeatPump(state,
                                            MSHeatPumpNum,
                                            FirstHVACIteration,
@@ -3180,14 +2797,14 @@ namespace HVACMultiSpeedHeatPump {
                                        k,
                                        1.0,
                                        1.0,
-                                       MSHeatPump.FullOutput(k),
+                                       mshp.FullOutput(k),
                                        QZnReq,
                                        OnOffAirFlowRatio,
                                        SupHeaterLoad);
-                        if (QZnReq >= MSHeatPump.FullOutput(k)) {
+                        if (QZnReq >= mshp.FullOutput(k)) {
                             SpeedNum = k;
                             PartLoadFrac = 1.0;
-                            SpeedRatio = (QZnReq - MSHeatPump.FullOutput(k - 1)) / (MSHeatPump.FullOutput(k) - MSHeatPump.FullOutput(k - 1));
+                            SpeedRatio = (QZnReq - mshp.FullOutput(k - 1)) / (mshp.FullOutput(k) - mshp.FullOutput(k - 1));
                             CalcMSHeatPump(state,
                                            MSHeatPumpNum,
                                            FirstHVACIteration,
@@ -3207,7 +2824,7 @@ namespace HVACMultiSpeedHeatPump {
         } else {
             // Calculate the part load fraction
             if (((QZnReq > HVAC::SmallLoad && QZnReq < FullOutput) || (QZnReq < (-1.0 * HVAC::SmallLoad) && QZnReq > FullOutput)) &&
-                (!MSHeatPump.Staged)) {
+                (!mshp.Staged)) {
                 // Check whether the low speed coil can meet the load or not
                 CalcMSHeatPump(
                     state, MSHeatPumpNum, FirstHVACIteration, compressorOp, 1, 0.0, 1.0, LowOutput, QZnReq, OnOffAirFlowRatio, SupHeaterLoad);
@@ -3240,14 +2857,14 @@ namespace HVACMultiSpeedHeatPump {
                             if (state.dataHVACMultiSpdHP->ErrCountCyc == 0) {
                                 ++state.dataHVACMultiSpdHP->ErrCountCyc; // TODO: Why is the error count shared among all heat pump units?
                                 ShowWarningError(state,
-                                                 format("Iteration limit exceeded calculating DX unit cycling ratio, for unit={}", MSHeatPump.Name));
+                                                 format("Iteration limit exceeded calculating DX unit cycling ratio, for unit={}", mshp.Name));
                                 ShowContinueErrorTimeStamp(state, format("Cycling ratio returned={:.2R}", PartLoadFrac));
                             } else {
                                 ++state.dataHVACMultiSpdHP->ErrCountCyc;
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
-                                    MSHeatPump.Name + "\": Iteration limit warning exceeding calculating DX unit cycling ratio  continues...",
-                                    MSHeatPump.ErrIndexCyc,
+                                    mshp.Name + "\": Iteration limit warning exceeding calculating DX unit cycling ratio  continues...",
+                                    mshp.ErrIndexCyc,
                                     PartLoadFrac,
                                     PartLoadFrac);
                             }
@@ -3255,14 +2872,14 @@ namespace HVACMultiSpeedHeatPump {
                     } else if (SolFla == -2) {
                         ShowFatalError(
                             state,
-                            format("DX unit cycling ratio calculation failed: cycling limits exceeded, for unit={}", MSHeatPump.DXCoolCoilName));
+                            format("DX unit cycling ratio calculation failed: cycling limits exceeded, for unit={}", mshp.CoolCoilName));
                     }
                 } else {
                     // Check to see which speed to meet the load
                     PartLoadFrac = 1.0;
                     SpeedRatio = 1.0;
                     if (QZnReq < (-1.0 * HVAC::SmallLoad)) { // Cooling
-                        for (i = 2; i <= MSHeatPump.NumOfSpeedCooling; ++i) {
+                        for (i = 2; i <= mshp.NumOfSpeedCooling; ++i) {
                             CalcMSHeatPump(state,
                                            MSHeatPumpNum,
                                            FirstHVACIteration,
@@ -3280,7 +2897,7 @@ namespace HVACMultiSpeedHeatPump {
                             }
                         }
                     } else {
-                        for (i = 2; i <= MSHeatPump.NumOfSpeedHeating; ++i) {
+                        for (i = 2; i <= mshp.NumOfSpeedHeating; ++i) {
                             CalcMSHeatPump(state,
                                            MSHeatPumpNum,
                                            FirstHVACIteration,
@@ -3324,14 +2941,14 @@ namespace HVACMultiSpeedHeatPump {
                             if (state.dataHVACMultiSpdHP->ErrCountVar == 0) {
                                 ++state.dataHVACMultiSpdHP->ErrCountVar;
                                 ShowWarningError(state,
-                                                 format("Iteration limit exceeded calculating DX unit speed ratio, for unit={}", MSHeatPump.Name));
+                                                 format("Iteration limit exceeded calculating DX unit speed ratio, for unit={}", mshp.Name));
                                 ShowContinueErrorTimeStamp(state, format("Speed ratio returned=[{:.2R}], Speed number ={}", SpeedRatio, SpeedNum));
                             } else {
                                 ++state.dataHVACMultiSpdHP->ErrCountVar;
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
-                                    MSHeatPump.Name + "\": Iteration limit warning exceeding calculating DX unit speed ratio continues...",
-                                    MSHeatPump.ErrIndexVar,
+                                    mshp.Name + "\": Iteration limit warning exceeding calculating DX unit speed ratio continues...",
+                                    mshp.ErrIndexVar,
                                     SpeedRatio,
                                     SpeedRatio);
                             }
@@ -3339,13 +2956,13 @@ namespace HVACMultiSpeedHeatPump {
                     } else if (SolFla == -2) {
                         ShowFatalError(
                             state,
-                            format("DX unit compressor speed calculation failed: speed limits exceeded, for unit={}", MSHeatPump.DXCoolCoilName));
+                            format("DX unit compressor speed calculation failed: speed limits exceeded, for unit={}", mshp.CoolCoilName));
                     }
                 }
             } else {
                 // Staged thermostat performance
-                if (MSHeatPump.StageNum != 0) {
-                    SpeedNum = std::abs(MSHeatPump.StageNum);
+                if (mshp.StageNum != 0) {
+                    SpeedNum = std::abs(mshp.StageNum);
                     if (SpeedNum == 1) {
                         CalcMSHeatPump(
                             state, MSHeatPumpNum, FirstHVACIteration, compressorOp, 1, 0.0, 1.0, LowOutput, QZnReq, OnOffAirFlowRatio, SupHeaterLoad);
@@ -3378,14 +2995,14 @@ namespace HVACMultiSpeedHeatPump {
                                         ++state.dataHVACMultiSpdHP->ErrCountCyc;
                                         ShowWarningError(
                                             state,
-                                            format("Iteration limit exceeded calculating DX unit cycling ratio, for unit={}", MSHeatPump.Name));
+                                            format("Iteration limit exceeded calculating DX unit cycling ratio, for unit={}", mshp.Name));
                                         ShowContinueErrorTimeStamp(state, format("Cycling ratio returned={:.2R}", PartLoadFrac));
                                     } else {
                                         ++state.dataHVACMultiSpdHP->ErrCountCyc;
                                         ShowRecurringWarningErrorAtEnd(
                                             state,
-                                            MSHeatPump.Name + "\": Iteration limit warning exceeding calculating DX unit cycling ratio  continues...",
-                                            MSHeatPump.ErrIndexCyc,
+                                            mshp.Name + "\": Iteration limit warning exceeding calculating DX unit cycling ratio  continues...",
+                                            mshp.ErrIndexCyc,
                                             PartLoadFrac,
                                             PartLoadFrac);
                                     }
@@ -3393,17 +3010,17 @@ namespace HVACMultiSpeedHeatPump {
                             } else if (SolFla == -2) {
                                 ShowFatalError(state,
                                                format("DX unit cycling ratio calculation failed: cycling limits exceeded, for unit={}",
-                                                      MSHeatPump.DXCoolCoilName));
+                                                      mshp.CoolCoilName));
                             }
                         } else {
                             FullOutput = LowOutput;
                             PartLoadFrac = 1.0;
                         }
                     } else {
-                        if (MSHeatPump.StageNum < 0) {
-                            SpeedNum = min(MSHeatPump.NumOfSpeedCooling, std::abs(MSHeatPump.StageNum));
+                        if (mshp.StageNum < 0) {
+                            SpeedNum = min(mshp.NumOfSpeedCooling, std::abs(mshp.StageNum));
                         } else {
-                            SpeedNum = min(MSHeatPump.NumOfSpeedHeating, std::abs(MSHeatPump.StageNum));
+                            SpeedNum = min(mshp.NumOfSpeedHeating, std::abs(mshp.StageNum));
                         }
                         CalcMSHeatPump(state,
                                        MSHeatPumpNum,
@@ -3457,16 +3074,16 @@ namespace HVACMultiSpeedHeatPump {
                                             ++state.dataHVACMultiSpdHP->ErrCountVar;
                                             ShowWarningError(
                                                 state,
-                                                format("Iteration limit exceeded calculating DX unit speed ratio, for unit={}", MSHeatPump.Name));
+                                                format("Iteration limit exceeded calculating DX unit speed ratio, for unit={}", mshp.Name));
                                             ShowContinueErrorTimeStamp(
                                                 state, format("Speed ratio returned=[{:.2R}], Speed number ={}", SpeedRatio, SpeedNum));
                                         } else {
                                             ++state.dataHVACMultiSpdHP->ErrCountVar;
                                             ShowRecurringWarningErrorAtEnd(
                                                 state,
-                                                MSHeatPump.Name +
+                                                mshp.Name +
                                                     "\": Iteration limit warning exceeding calculating DX unit speed ratio continues...",
-                                                MSHeatPump.ErrIndexVar,
+                                                mshp.ErrIndexVar,
                                                 SpeedRatio,
                                                 SpeedRatio);
                                         }
@@ -3474,7 +3091,7 @@ namespace HVACMultiSpeedHeatPump {
                                 } else if (SolFla == -2) {
                                     ShowFatalError(state,
                                                    format("DX unit compressor speed calculation failed: speed limits exceeded, for unit={}",
-                                                          MSHeatPump.DXCoolCoilName));
+                                                          mshp.CoolCoilName));
                                 }
                             } else {
                                 SpeedRatio = 1.0;
@@ -3493,8 +3110,8 @@ namespace HVACMultiSpeedHeatPump {
         if ((QZnReq > HVAC::SmallLoad && QZnReq > FullOutput)) {
             PartLoadFrac = 1.0;
             SpeedRatio = 1.0;
-            if (MSHeatPump.Staged && SpeedNum == 1) SpeedRatio = 0.0;
-            if (OutsideDryBulbTemp <= MSHeatPump.SuppMaxAirTemp) {
+            if (mshp.Staged && SpeedNum == 1) SpeedRatio = 0.0;
+            if (OutsideDryBulbTemp <= mshp.SuppMaxAirTemp) {
                 SupHeaterLoad = QZnReq - FullOutput;
             } else {
                 SupHeaterLoad = 0.0;
@@ -3513,7 +3130,7 @@ namespace HVACMultiSpeedHeatPump {
         }
 
         // check the outlet of the supplemental heater to be lower than the maximum supplemental heater supply air temperature
-        if (state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).Temp > MSHeatPump.SuppMaxAirTemp && SupHeaterLoad > 0.0) {
+        if (s_node->Node(mshp.AirOutletNode).Temp > mshp.SuppMaxAirTemp && SupHeaterLoad > 0.0) {
 
             //   If the supply air temperature is to high, turn off the supplemental heater to recalculate the outlet temperature
             SupHeaterLoad = 0.0;
@@ -3523,10 +3140,10 @@ namespace HVACMultiSpeedHeatPump {
             //   the supplemental heater, otherwise leave the supplemental heater off. If the supplemental heater is to be turned on,
             //   use the outlet conditions when the supplemental heater was off (CALL above) as the inlet conditions for the calculation
             //   of supplemental heater load to just meet the maximum supply air temperature from the supplemental heater.
-            if (state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).Temp < MSHeatPump.SuppMaxAirTemp) {
-                CpAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).HumRat);
-                SupHeaterLoad = state.dataLoopNodes->Node(MSHeatPump.AirInletNodeNum).MassFlowRate * CpAir *
-                                (MSHeatPump.SuppMaxAirTemp - state.dataLoopNodes->Node(MSHeatPump.AirOutletNodeNum).Temp);
+            if (s_node->Node(mshp.AirOutletNode).Temp < mshp.SuppMaxAirTemp) {
+                CpAir = Psychrometrics::PsyCpAirFnW(s_node->Node(mshp.AirOutletNode).HumRat);
+                SupHeaterLoad = s_node->Node(mshp.AirInletNode).MassFlowRate * CpAir *
+                                (mshp.SuppMaxAirTemp - s_node->Node(mshp.AirOutletNode).Temp);
 
             } else {
                 SupHeaterLoad = 0.0;
@@ -3561,8 +3178,6 @@ namespace HVACMultiSpeedHeatPump {
         //  This routine will calculates MSHP performance based on given system load
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        int OutletNode;            // MSHP air outlet node
-        int InletNode;             // MSHP air inlet node
         Real64 OutsideDryBulbTemp; // Outdoor dry bulb temperature [C]
         Real64 AirMassFlow;        // Air mass flow rate [kg/s]
         Real64 SavePartloadRatio;
@@ -3571,21 +3186,20 @@ namespace HVACMultiSpeedHeatPump {
         Real64 MinWaterFlow; // minimum water flow rate
         Real64 ErrorToler;   // supplemental heating coil convergence tolerance
 
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &s_node = state.dataLoopNodes;
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
 
-        OutletNode = MSHeatPump.AirOutletNodeNum;
-        InletNode = MSHeatPump.AirInletNodeNum;
-        if (MSHeatPump.DXHeatCoilIndex > 0) {
-            if (state.dataDXCoils->DXCoil(MSHeatPump.DXHeatCoilIndex).IsSecondaryDXCoilInZone) {
-                OutsideDryBulbTemp =
-                    state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataDXCoils->DXCoil(MSHeatPump.DXHeatCoilIndex).SecZonePtr).ZT;
+        if (mshp.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed && mshp.HeatCoilNum > 0) {
+            auto const &dxCoil = state.dataDXCoils->DXCoil(mshp.HeatCoilNum);
+            if (dxCoil.IsSecondaryDXCoilInZone) {
+                OutsideDryBulbTemp = state.dataZoneTempPredictorCorrector->zoneHeatBalance(dxCoil.SecZonePtr).ZT;
             } else {
                 OutsideDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
             }
-        } else if (MSHeatPump.DXCoolCoilIndex > 0) {
-            if (state.dataDXCoils->DXCoil(MSHeatPump.DXCoolCoilIndex).IsSecondaryDXCoilInZone) {
-                OutsideDryBulbTemp =
-                    state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataDXCoils->DXCoil(MSHeatPump.DXCoolCoilIndex).SecZonePtr).ZT;
+        } else if (mshp.coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed && mshp.CoolCoilNum > 0) {
+            auto const &dxCoil = state.dataDXCoils->DXCoil(mshp.CoolCoilNum);
+            if (dxCoil.IsSecondaryDXCoilInZone) {
+                OutsideDryBulbTemp = state.dataZoneTempPredictorCorrector->zoneHeatBalance(dxCoil.SecZonePtr).ZT;
             } else {
                 OutsideDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
             }
@@ -3600,202 +3214,207 @@ namespace HVACMultiSpeedHeatPump {
         // Set inlet air mass flow rate based on PLR and compressor on/off air flow rates
         SetAverageAirFlow(state, MSHeatPumpNum, PartLoadFrac, OnOffAirFlowRatio, SpeedNum, SpeedRatio);
 
-        AirMassFlow = state.dataLoopNodes->Node(InletNode).MassFlowRate;
+        AirMassFlow = s_node->Node(mshp.AirInletNode).MassFlowRate;
         // if blow through, simulate fan then coils
-        if (MSHeatPump.fanPlace == HVAC::FanPlace::BlowThru) {
-            state.dataFans->fans(MSHeatPump.FanNum)->simulate(state, FirstHVACIteration, state.dataHVACMultiSpdHP->FanSpeedRatio);
+        if (mshp.fanPlace == HVAC::FanPlace::BlowThru) {
+            state.dataFans->fans(mshp.FanNum)->simulate(state, FirstHVACIteration, state.dataHVACMultiSpdHP->FanSpeedRatio);
             if (QZnReq < (-1.0 * HVAC::SmallLoad)) {
-                if (OutsideDryBulbTemp > MSHeatPump.MinOATCompressorCooling) {
+                if (OutsideDryBulbTemp > mshp.MinOATCompressorCooling) {
                     DXCoils::SimDXCoilMultiSpeed(state,
-                                                 MSHeatPump.DXCoolCoilName,
+                                                 mshp.CoolCoilName,
                                                  SpeedRatio,
                                                  PartLoadFrac,
-                                                 MSHeatPump.DXCoolCoilIndex,
+                                                 mshp.CoolCoilNum,
                                                  SpeedNum,
-                                                 MSHeatPump.fanOp,
+                                                 mshp.fanOp,
                                                  compressorOp);
                     SavePartloadRatio = PartLoadFrac;
                     SaveSpeedRatio = SpeedRatio;
                 } else {
                     DXCoils::SimDXCoilMultiSpeed(
-                        state, MSHeatPump.DXCoolCoilName, 0.0, 0.0, MSHeatPump.DXCoolCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                        state, mshp.CoolCoilName, 0.0, 0.0, mshp.CoolCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                 }
-                state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(MSHeatPump.DXCoolCoilIndex);
+                state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(mshp.CoolCoilNum);
             } else {
                 DXCoils::SimDXCoilMultiSpeed(
-                    state, MSHeatPump.DXCoolCoilName, 0.0, 0.0, MSHeatPump.DXCoolCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                    state, mshp.CoolCoilName, 0.0, 0.0, mshp.CoolCoilNum, SpeedNum, mshp.fanOp, compressorOp);
             }
-            if (MSHeatPump.HeatCoilType == MultiSpeedHeatingCoil) {
+            
+            if (mshp.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                 if (QZnReq > HVAC::SmallLoad) {
-                    if (OutsideDryBulbTemp > MSHeatPump.MinOATCompressorHeating) {
+                    if (OutsideDryBulbTemp > mshp.MinOATCompressorHeating) {
                         DXCoils::SimDXCoilMultiSpeed(state,
-                                                     MSHeatPump.DXHeatCoilName,
+                                                     mshp.HeatCoilName,
                                                      SpeedRatio,
                                                      PartLoadFrac,
-                                                     MSHeatPump.DXHeatCoilIndex,
+                                                     mshp.HeatCoilNum,
                                                      SpeedNum,
-                                                     MSHeatPump.fanOp,
+                                                     mshp.fanOp,
                                                      compressorOp);
                         SavePartloadRatio = PartLoadFrac;
                         SaveSpeedRatio = SpeedRatio;
                     } else {
                         DXCoils::SimDXCoilMultiSpeed(
-                            state, MSHeatPump.DXHeatCoilName, 0.0, 0.0, MSHeatPump.DXHeatCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                            state, mshp.HeatCoilName, 0.0, 0.0, mshp.HeatCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                     }
-                    state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(MSHeatPump.DXHeatCoilIndex);
+                    state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(mshp.HeatCoilNum);
                 } else {
                     DXCoils::SimDXCoilMultiSpeed(
-                        state, MSHeatPump.DXHeatCoilName, 0.0, 0.0, MSHeatPump.DXHeatCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                        state, mshp.HeatCoilName, 0.0, 0.0, mshp.HeatCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                 }
-            } else if (MSHeatPump.HeatCoilType == HVAC::Coil_HeatingElectric_MultiStage ||
-                       MSHeatPump.HeatCoilType == HVAC::Coil_HeatingGas_MultiStage) {
+                
+            } else if (mshp.heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                       mshp.heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
                 if (QZnReq > HVAC::SmallLoad) {
                     HeatingCoils::SimulateHeatingCoilComponents(
-                        state, MSHeatPump.HeatCoilName, FirstHVACIteration, _, 0, _, _, MSHeatPump.fanOp, PartLoadFrac, SpeedNum, SpeedRatio);
+                        state, mshp.HeatCoilName, FirstHVACIteration, _, 0, _, _, mshp.fanOp, PartLoadFrac, SpeedNum, SpeedRatio);
                 } else {
                     HeatingCoils::SimulateHeatingCoilComponents(
-                        state, MSHeatPump.HeatCoilName, FirstHVACIteration, _, 0, _, _, MSHeatPump.fanOp, 0.0, SpeedNum, 0.0);
+                        state, mshp.HeatCoilName, FirstHVACIteration, _, 0, _, _, mshp.fanOp, 0.0, SpeedNum, 0.0);
                 }
             } else {
-                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, QZnReq, MSHeatPump.fanOp, QCoilActual, PartLoadFrac);
+                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, QZnReq, mshp.fanOp, QCoilActual, PartLoadFrac);
             }
             // Call twice to ensure the fan outlet conditions are updated
-            state.dataFans->fans(MSHeatPump.FanNum)->simulate(state, FirstHVACIteration, state.dataHVACMultiSpdHP->FanSpeedRatio);
+            state.dataFans->fans(mshp.FanNum)->simulate(state, FirstHVACIteration, state.dataHVACMultiSpdHP->FanSpeedRatio);
             if (QZnReq < (-1.0 * HVAC::SmallLoad)) {
-                if (OutsideDryBulbTemp > MSHeatPump.MinOATCompressorCooling) {
+                if (OutsideDryBulbTemp > mshp.MinOATCompressorCooling) {
                     DXCoils::SimDXCoilMultiSpeed(state,
-                                                 MSHeatPump.DXCoolCoilName,
+                                                 mshp.CoolCoilName,
                                                  SpeedRatio,
                                                  PartLoadFrac,
-                                                 MSHeatPump.DXCoolCoilIndex,
+                                                 mshp.CoolCoilNum,
                                                  SpeedNum,
-                                                 MSHeatPump.fanOp,
+                                                 mshp.fanOp,
                                                  compressorOp);
                     SavePartloadRatio = PartLoadFrac;
                     SaveSpeedRatio = SpeedRatio;
                 } else {
                     DXCoils::SimDXCoilMultiSpeed(
-                        state, MSHeatPump.DXCoolCoilName, 0.0, 0.0, MSHeatPump.DXCoolCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                        state, mshp.CoolCoilName, 0.0, 0.0, mshp.CoolCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                 }
-                state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(MSHeatPump.DXCoolCoilIndex);
+                state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(mshp.CoolCoilNum);
             } else {
                 DXCoils::SimDXCoilMultiSpeed(
-                    state, MSHeatPump.DXCoolCoilName, 0.0, 0.0, MSHeatPump.DXCoolCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                    state, mshp.CoolCoilName, 0.0, 0.0, mshp.CoolCoilNum, SpeedNum, mshp.fanOp, compressorOp);
             }
-            if (MSHeatPump.HeatCoilType == MultiSpeedHeatingCoil) {
+            
+            if (mshp.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                 if (QZnReq > HVAC::SmallLoad) {
-                    if (OutsideDryBulbTemp > MSHeatPump.MinOATCompressorHeating) {
+                    if (OutsideDryBulbTemp > mshp.MinOATCompressorHeating) {
                         DXCoils::SimDXCoilMultiSpeed(state,
-                                                     MSHeatPump.DXHeatCoilName,
+                                                     mshp.HeatCoilName,
                                                      SpeedRatio,
                                                      PartLoadFrac,
-                                                     MSHeatPump.DXHeatCoilIndex,
+                                                     mshp.HeatCoilNum,
                                                      SpeedNum,
-                                                     MSHeatPump.fanOp,
+                                                     mshp.fanOp,
                                                      compressorOp);
                         SavePartloadRatio = PartLoadFrac;
                         SaveSpeedRatio = SpeedRatio;
                     } else {
                         DXCoils::SimDXCoilMultiSpeed(
-                            state, MSHeatPump.DXHeatCoilName, 0.0, 0.0, MSHeatPump.DXHeatCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                            state, mshp.HeatCoilName, 0.0, 0.0, mshp.HeatCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                     }
-                    state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(MSHeatPump.DXHeatCoilIndex);
+                    state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(mshp.HeatCoilNum);
                 } else {
                     DXCoils::SimDXCoilMultiSpeed(
-                        state, MSHeatPump.DXHeatCoilName, 0.0, 0.0, MSHeatPump.DXHeatCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                        state, mshp.HeatCoilName, 0.0, 0.0, mshp.HeatCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                 }
-            } else if (MSHeatPump.HeatCoilType == HVAC::Coil_HeatingElectric_MultiStage ||
-                       MSHeatPump.HeatCoilType == HVAC::Coil_HeatingGas_MultiStage) {
+                
+            } else if (mshp.heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                       mshp.heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
                 if (QZnReq > HVAC::SmallLoad) {
                     HeatingCoils::SimulateHeatingCoilComponents(
-                        state, MSHeatPump.HeatCoilName, FirstHVACIteration, _, 0, _, _, MSHeatPump.fanOp, PartLoadFrac, SpeedNum, SpeedRatio);
+                        state, mshp.HeatCoilName, FirstHVACIteration, _, 0, _, _, mshp.fanOp, PartLoadFrac, SpeedNum, SpeedRatio);
                 } else {
                     HeatingCoils::SimulateHeatingCoilComponents(
-                        state, MSHeatPump.HeatCoilName, FirstHVACIteration, _, 0, _, _, MSHeatPump.fanOp, 0.0, SpeedNum, 0.0);
+                        state, mshp.HeatCoilName, FirstHVACIteration, _, 0, _, _, mshp.fanOp, 0.0, SpeedNum, 0.0);
                 }
             } else {
-                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, QZnReq, MSHeatPump.fanOp, QCoilActual, PartLoadFrac);
+                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, QZnReq, mshp.fanOp, QCoilActual, PartLoadFrac);
             }
             //  Simulate supplemental heating coil for blow through fan
-            if (MSHeatPump.SuppHeatCoilNum > 0) {
-                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, SupHeaterLoad, MSHeatPump.fanOp, QCoilActual);
+
+            if (mshp.SuppHeatCoilNum > 0) {
+                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, SupHeaterLoad, mshp.fanOp, QCoilActual);
             }
         } else { // otherwise simulate DX coils then fan then supplemental heater
             if (QZnReq < (-1.0 * HVAC::SmallLoad)) {
-                if (OutsideDryBulbTemp > MSHeatPump.MinOATCompressorCooling) {
+                if (OutsideDryBulbTemp > mshp.MinOATCompressorCooling) {
                     DXCoils::SimDXCoilMultiSpeed(state,
-                                                 MSHeatPump.DXCoolCoilName,
+                                                 mshp.CoolCoilName,
                                                  SpeedRatio,
                                                  PartLoadFrac,
-                                                 MSHeatPump.DXCoolCoilIndex,
+                                                 mshp.CoolCoilNum,
                                                  SpeedNum,
-                                                 MSHeatPump.fanOp,
+                                                 mshp.fanOp,
                                                  compressorOp);
                     SavePartloadRatio = PartLoadFrac;
                     SaveSpeedRatio = SpeedRatio;
                 } else {
                     DXCoils::SimDXCoilMultiSpeed(
-                        state, MSHeatPump.DXCoolCoilName, 0.0, 0.0, MSHeatPump.DXCoolCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                        state, mshp.CoolCoilName, 0.0, 0.0, mshp.CoolCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                 }
-                state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(MSHeatPump.DXCoolCoilIndex);
+                state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(mshp.CoolCoilNum);
             } else {
                 DXCoils::SimDXCoilMultiSpeed(
-                    state, MSHeatPump.DXCoolCoilName, 0.0, 0.0, MSHeatPump.DXCoolCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                    state, mshp.CoolCoilName, 0.0, 0.0, mshp.CoolCoilNum, SpeedNum, mshp.fanOp, compressorOp);
             }
-            if (MSHeatPump.HeatCoilType == MultiSpeedHeatingCoil) {
+            if (mshp.heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                 if (QZnReq > HVAC::SmallLoad) {
-                    if (OutsideDryBulbTemp > MSHeatPump.MinOATCompressorHeating) {
+                    if (OutsideDryBulbTemp > mshp.MinOATCompressorHeating) {
                         DXCoils::SimDXCoilMultiSpeed(state,
-                                                     MSHeatPump.DXHeatCoilName,
+                                                     mshp.HeatCoilName,
                                                      SpeedRatio,
                                                      PartLoadFrac,
-                                                     MSHeatPump.DXHeatCoilIndex,
+                                                     mshp.HeatCoilNum,
                                                      SpeedNum,
-                                                     MSHeatPump.fanOp,
+                                                     mshp.fanOp,
                                                      compressorOp);
                         SavePartloadRatio = PartLoadFrac;
                         SaveSpeedRatio = SpeedRatio;
                     } else {
                         DXCoils::SimDXCoilMultiSpeed(
-                            state, MSHeatPump.DXHeatCoilName, 0.0, 0.0, MSHeatPump.DXHeatCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                            state, mshp.HeatCoilName, 0.0, 0.0, mshp.HeatCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                     }
-                    state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(MSHeatPump.DXHeatCoilIndex);
+                    state.dataHVACMultiSpdHP->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(mshp.HeatCoilNum);
                 } else {
                     DXCoils::SimDXCoilMultiSpeed(
-                        state, MSHeatPump.DXHeatCoilName, 0.0, 0.0, MSHeatPump.DXHeatCoilIndex, SpeedNum, MSHeatPump.fanOp, compressorOp);
+                        state, mshp.HeatCoilName, 0.0, 0.0, mshp.HeatCoilNum, SpeedNum, mshp.fanOp, compressorOp);
                 }
-            } else if (MSHeatPump.HeatCoilType == HVAC::Coil_HeatingElectric_MultiStage ||
-                       MSHeatPump.HeatCoilType == HVAC::Coil_HeatingGas_MultiStage) {
+            } else if (mshp.heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                       mshp.heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
                 if (QZnReq > HVAC::SmallLoad) {
                     HeatingCoils::SimulateHeatingCoilComponents(
-                        state, MSHeatPump.HeatCoilName, FirstHVACIteration, _, 0, _, _, MSHeatPump.fanOp, PartLoadFrac, SpeedNum, SpeedRatio);
+                        state, mshp.HeatCoilName, FirstHVACIteration, _, 0, _, _, mshp.fanOp, PartLoadFrac, SpeedNum, SpeedRatio);
                 } else {
                     HeatingCoils::SimulateHeatingCoilComponents(
-                        state, MSHeatPump.HeatCoilName, FirstHVACIteration, _, 0, _, _, MSHeatPump.fanOp, 0.0, SpeedNum, 0.0);
+                        state, mshp.HeatCoilName, FirstHVACIteration, _, 0, _, _, mshp.fanOp, 0.0, SpeedNum, 0.0);
                 }
             } else {
-                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, QZnReq, MSHeatPump.fanOp, QCoilActual, PartLoadFrac);
+                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, QZnReq, mshp.fanOp, QCoilActual, PartLoadFrac);
             }
-            state.dataFans->fans(MSHeatPump.FanNum)->simulate(state, FirstHVACIteration, state.dataHVACMultiSpdHP->FanSpeedRatio);
+            state.dataFans->fans(mshp.FanNum)->simulate(state, FirstHVACIteration, state.dataHVACMultiSpdHP->FanSpeedRatio);
             //  Simulate supplemental heating coil for draw through fan
-            if (MSHeatPump.SuppHeatCoilNum > 0) {
-                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, SupHeaterLoad, MSHeatPump.fanOp, QCoilActual);
+            if (mshp.SuppHeatCoilNum > 0) {
+                CalcNonDXHeatingCoils(state, MSHeatPumpNum, FirstHVACIteration, SupHeaterLoad, mshp.fanOp, QCoilActual);
             }
         }
 
         // calculate sensible load met
         Real64 SensibleOutput(0.0); // sensible output rate
         // calculate sensible load met using delta enthalpy at a constant (minimum) humidity ratio)
-        Real64 MinHumRat = state.dataLoopNodes->Node(MSHeatPump.NodeNumOfControlledZone).HumRat;
-        if (state.dataLoopNodes->Node(OutletNode).Temp < state.dataLoopNodes->Node(MSHeatPump.NodeNumOfControlledZone).Temp)
-            MinHumRat = state.dataLoopNodes->Node(OutletNode).HumRat;
-        SensibleOutput = AirMassFlow * Psychrometrics::PsyDeltaHSenFnTdb2W2Tdb1W1(state.dataLoopNodes->Node(OutletNode).Temp,
+        Real64 MinHumRat = s_node->Node(mshp.NodeNumOfControlledZone).HumRat;
+        if (s_node->Node(mshp.AirOutletNode).Temp < s_node->Node(mshp.NodeNumOfControlledZone).Temp)
+            MinHumRat = s_node->Node(mshp.AirOutletNode).HumRat;
+        SensibleOutput = AirMassFlow * Psychrometrics::PsyDeltaHSenFnTdb2W2Tdb1W1(s_node->Node(mshp.AirOutletNode).Temp,
                                                                                   MinHumRat,
-                                                                                  state.dataLoopNodes->Node(MSHeatPump.NodeNumOfControlledZone).Temp,
+                                                                                  s_node->Node(mshp.NodeNumOfControlledZone).Temp,
                                                                                   MinHumRat);
-        LoadMet = SensibleOutput - MSHeatPump.LoadLoss;
+        LoadMet = SensibleOutput - mshp.LoadLoss;
 
-        MSHeatPump.LoadMet = LoadMet;
+        mshp.LoadMet = LoadMet;
     }
 
     void UpdateMSHeatPump(EnergyPlusData &state, int const MSHeatPumpNum) // Engine driven heat pump number
@@ -3807,22 +3426,20 @@ namespace HVACMultiSpeedHeatPump {
         // PURPOSE OF THIS SUBROUTINE:
         //  This routine will update MSHP performance and calculate heat recovery rate and crankcase heater power
 
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+      
         // Calculate heat recovery
-        if (state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatRecActive) {
+        if (mshp.HeatRecActive) {
             MSHPHeatRecovery(state, MSHeatPumpNum);
         }
 
         if (state.afn->distribution_simulated) {
-            state.dataAirLoop->AirLoopAFNInfo(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).AirLoopNumber).LoopSystemOnMassFlowrate =
-                state.dataHVACMultiSpdHP->CompOnMassFlow;
-            state.dataAirLoop->AirLoopAFNInfo(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).AirLoopNumber).LoopSystemOffMassFlowrate =
-                state.dataHVACMultiSpdHP->CompOffMassFlow;
-            state.dataAirLoop->AirLoopAFNInfo(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).AirLoopNumber).LoopFanOperationMode =
-                state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).fanOp;
-            state.dataAirLoop->AirLoopAFNInfo(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).AirLoopNumber).LoopOnOffFanPartLoadRatio =
-                state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).FanPartLoadRatio;
-            state.dataAirLoop->AirLoopAFNInfo(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).AirLoopNumber).LoopCompCycRatio =
-                state.dataHVACMultiSpdHP->MSHeatPumpReport(MSHeatPumpNum).CycRatio;
+            auto &airLoopAFN = state.dataAirLoop->AirLoopAFNInfo(mshp.AirLoopNumber);
+            airLoopAFN.LoopSystemOnMassFlowrate = state.dataHVACMultiSpdHP->CompOnMassFlow;
+            airLoopAFN.LoopSystemOffMassFlowrate = state.dataHVACMultiSpdHP->CompOffMassFlow;
+            airLoopAFN.LoopFanOperationMode = mshp.fanOp;
+            airLoopAFN.LoopOnOffFanPartLoadRatio = mshp.FanPartLoadRatio;
+            airLoopAFN.LoopCompCycRatio = state.dataHVACMultiSpdHP->MSHeatPumpReport(MSHeatPumpNum).CycRatio;
         }
     }
 
@@ -3839,34 +3456,34 @@ namespace HVACMultiSpeedHeatPump {
 
         Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
 
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
         auto &MSHeatPumpReport = state.dataHVACMultiSpdHP->MSHeatPumpReport(MSHeatPumpNum);
 
-        MSHeatPumpReport.ElecPowerConsumption = MSHeatPump.ElecPower * TimeStepSysSec; // + &
-        MSHeatPumpReport.HeatRecoveryEnergy = MSHeatPump.HeatRecoveryRate * TimeStepSysSec;
+        MSHeatPumpReport.ElecPowerConsumption = mshp.ElecPower * TimeStepSysSec; // + &
+        MSHeatPumpReport.HeatRecoveryEnergy = mshp.HeatRecoveryRate * TimeStepSysSec;
 
         MSHeatPumpReport.AuxElecHeatConsumption = 0.0;
         MSHeatPumpReport.AuxElecCoolConsumption = 0.0;
 
-        MSHeatPump.AuxElecPower = MSHeatPump.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR +
-                                  MSHeatPump.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR);
-        if (MSHeatPump.HeatCoolMode == ModeOfOperation::CoolingMode) {
-            MSHeatPumpReport.AuxElecCoolConsumption = MSHeatPump.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR * TimeStepSysSec;
+        mshp.AuxElecPower = mshp.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR +
+                                  mshp.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR);
+        if (mshp.HeatCoolMode == ModeOfOperation::CoolingMode) {
+            MSHeatPumpReport.AuxElecCoolConsumption = mshp.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR * TimeStepSysSec;
         }
-        if (MSHeatPump.HeatCoolMode == ModeOfOperation::HeatingMode) {
-            MSHeatPumpReport.AuxElecHeatConsumption = MSHeatPump.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR * TimeStepSysSec;
+        if (mshp.HeatCoolMode == ModeOfOperation::HeatingMode) {
+            MSHeatPumpReport.AuxElecHeatConsumption = mshp.AuxOnCyclePower * state.dataHVACMultiSpdHP->SaveCompressorPLR * TimeStepSysSec;
         }
-        if (MSHeatPump.LastMode == ModeOfOperation::HeatingMode) {
+        if (mshp.LastMode == ModeOfOperation::HeatingMode) {
             MSHeatPumpReport.AuxElecHeatConsumption +=
-                MSHeatPump.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR) * TimeStepSysSec;
+                mshp.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR) * TimeStepSysSec;
         } else {
             MSHeatPumpReport.AuxElecCoolConsumption +=
-                MSHeatPump.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR) * TimeStepSysSec;
+                mshp.AuxOffCyclePower * (1.0 - state.dataHVACMultiSpdHP->SaveCompressorPLR) * TimeStepSysSec;
         }
 
-        if (MSHeatPump.FirstPass) {
+        if (mshp.FirstPass) {
             if (!state.dataGlobal->SysSizingCalc) {
-                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, state.dataSize->CurSysNum, MSHeatPump.FirstPass);
+                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, state.dataSize->CurSysNum, mshp.FirstPass);
             }
         }
 
@@ -3889,16 +3506,15 @@ namespace HVACMultiSpeedHeatPump {
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         Real64 HeatRecOutletTemp; // Heat reclaim outlet temp [C]
 
+        auto &s_node = state.dataLoopNodes;
         auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
-        // Begin routine
-        int HeatRecInNode = mshp.HeatRecInletNodeNum;
-        int HeatRecOutNode = mshp.HeatRecOutletNodeNum;
-
+        // Begin routine // LOL
+        
         // Inlet node to the heat recovery heat exchanger
-        Real64 HeatRecInletTemp = state.dataLoopNodes->Node(HeatRecInNode).Temp;
+        Real64 HeatRecInletTemp = s_node->Node(mshp.HeatRecFluidInletNode).Temp;
 
         // Set heat recovery mass flow rates
-        Real64 HeatRecMassFlowRate = state.dataLoopNodes->Node(HeatRecInNode).MassFlowRate;
+        Real64 HeatRecMassFlowRate = s_node->Node(mshp.HeatRecFluidInletNode).MassFlowRate;
 
         Real64 QHeatRec = state.dataHVACGlobal->MSHPWasteHeat;
 
@@ -3916,9 +3532,9 @@ namespace HVACMultiSpeedHeatPump {
             QHeatRec = 0.0;
         }
 
-        PlantUtilities::SafeCopyPlantNode(state, HeatRecInNode, HeatRecOutNode);
+        PlantUtilities::SafeCopyPlantNode(state, mshp.HeatRecFluidInletNode, mshp.HeatRecFluidOutletNode);
         // changed outputs
-        state.dataLoopNodes->Node(HeatRecOutNode).Temp = HeatRecOutletTemp;
+        s_node->Node(mshp.HeatRecFluidOutletNode).Temp = HeatRecOutletTemp;
 
         mshp.HeatRecoveryRate = QHeatRec;
         mshp.HeatRecoveryInletTemp = HeatRecInletTemp;
@@ -3945,65 +3561,63 @@ namespace HVACMultiSpeedHeatPump {
         // Set the average air mass flow rates using the part load fraction of the heat pump for this time step
         // Set OnOffAirFlowRatio to be used by DX coils
 
-        // Using/Aliasing
+        auto &s_node = state.dataLoopNodes;
+      
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        // Why? Why are these global variables?
         auto &MSHPMassFlowRateHigh = state.dataHVACGlobal->MSHPMassFlowRateHigh;
         auto &MSHPMassFlowRateLow = state.dataHVACGlobal->MSHPMassFlowRateLow;
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        int InletNode;              // inlet node number for PTHPNum
         Real64 AverageUnitMassFlow; // average supply air mass flow rate over time step
 
         MSHPMassFlowRateLow = 0.0;  // Mass flow rate at low speed
         MSHPMassFlowRateHigh = 0.0; // Mass flow rate at high speed
 
-        if (!state.dataZoneEnergyDemand->CurDeadBandOrSetback(state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).ControlZoneNum) &&
+        if (!state.dataZoneEnergyDemand->CurDeadBandOrSetback(mshp.ControlZoneNum) &&
             present(SpeedNum)) {
-            if (state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatCoolMode == ModeOfOperation::HeatingMode) {
+            if (mshp.HeatCoolMode == ModeOfOperation::HeatingMode) {
                 if (SpeedNum == 1) {
-                    state.dataHVACMultiSpdHP->CompOnMassFlow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(SpeedNum);
-                    state.dataHVACMultiSpdHP->CompOnFlowRatio = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatingSpeedRatio(SpeedNum);
-                    MSHPMassFlowRateLow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(1);
-                    MSHPMassFlowRateHigh = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(1);
+                    state.dataHVACMultiSpdHP->CompOnMassFlow = mshp.HeatMassFlowRate(SpeedNum);
+                    state.dataHVACMultiSpdHP->CompOnFlowRatio = mshp.HeatingSpeedRatio(SpeedNum);
+                    MSHPMassFlowRateLow = mshp.HeatMassFlowRate(1);
+                    MSHPMassFlowRateHigh = mshp.HeatMassFlowRate(1);
                 } else if (SpeedNum > 1) {
                     state.dataHVACMultiSpdHP->CompOnMassFlow =
-                        SpeedRatio * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(SpeedNum) +
-                        (1.0 - SpeedRatio) * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(SpeedNum - 1);
+                        SpeedRatio * mshp.HeatMassFlowRate(SpeedNum) + (1.0 - SpeedRatio) * mshp.HeatMassFlowRate(SpeedNum - 1);
                     state.dataHVACMultiSpdHP->CompOnFlowRatio =
-                        SpeedRatio * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatingSpeedRatio(SpeedNum) +
-                        (1.0 - SpeedRatio) * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatingSpeedRatio(SpeedNum - 1);
-                    MSHPMassFlowRateLow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(SpeedNum - 1);
-                    MSHPMassFlowRateHigh = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(SpeedNum);
+                        SpeedRatio * mshp.HeatingSpeedRatio(SpeedNum) + (1.0 - SpeedRatio) * mshp.HeatingSpeedRatio(SpeedNum - 1);
+                    MSHPMassFlowRateLow = mshp.HeatMassFlowRate(SpeedNum - 1);
+                    MSHPMassFlowRateHigh = mshp.HeatMassFlowRate(SpeedNum);
                 }
-            } else if (state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatCoolMode == ModeOfOperation::CoolingMode) {
+                
+            } else if (mshp.HeatCoolMode == ModeOfOperation::CoolingMode) {
                 if (SpeedNum == 1) {
-                    state.dataHVACMultiSpdHP->CompOnMassFlow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(SpeedNum);
-                    state.dataHVACMultiSpdHP->CompOnFlowRatio = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolingSpeedRatio(SpeedNum);
-                    MSHPMassFlowRateLow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(1);
-                    MSHPMassFlowRateHigh = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(1);
+                    state.dataHVACMultiSpdHP->CompOnMassFlow = mshp.CoolMassFlowRate(SpeedNum);
+                    state.dataHVACMultiSpdHP->CompOnFlowRatio = mshp.CoolingSpeedRatio(SpeedNum);
+                    MSHPMassFlowRateLow = mshp.CoolMassFlowRate(1);
+                    MSHPMassFlowRateHigh = mshp.CoolMassFlowRate(1);
                 } else if (SpeedNum > 1) {
                     state.dataHVACMultiSpdHP->CompOnMassFlow =
-                        SpeedRatio * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(SpeedNum) +
-                        (1.0 - SpeedRatio) * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(SpeedNum - 1);
+                        SpeedRatio * mshp.CoolMassFlowRate(SpeedNum) + (1.0 - SpeedRatio) * mshp.CoolMassFlowRate(SpeedNum - 1);
                     state.dataHVACMultiSpdHP->CompOnFlowRatio =
-                        SpeedRatio * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolingSpeedRatio(SpeedNum) +
-                        (1.0 - SpeedRatio) * state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolingSpeedRatio(SpeedNum - 1);
-                    MSHPMassFlowRateLow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(SpeedNum - 1);
-                    MSHPMassFlowRateHigh = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(SpeedNum);
+                        SpeedRatio * mshp.CoolingSpeedRatio(SpeedNum) + (1.0 - SpeedRatio) * mshp.CoolingSpeedRatio(SpeedNum - 1);
+                    MSHPMassFlowRateLow = mshp.CoolMassFlowRate(SpeedNum - 1);
+                    MSHPMassFlowRateHigh = mshp.CoolMassFlowRate(SpeedNum);
                 }
             }
         }
-        InletNode = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).AirInletNodeNum;
-
+        
         // Set up fan flow rate during compressor off time
-        if (state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).fanOp == HVAC::FanOp::Continuous && present(SpeedNum)) {
-            if (state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).AirFlowControl == AirflowControl::UseCompressorOnFlow &&
+        if (mshp.fanOp == HVAC::FanOp::Continuous && present(SpeedNum)) {
+            if (mshp.AirFlowControl == AirflowControl::UseCompressorOnFlow &&
                 state.dataHVACMultiSpdHP->CompOnMassFlow > 0.0) {
-                if (state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).LastMode == ModeOfOperation::HeatingMode) {
-                    state.dataHVACMultiSpdHP->CompOffMassFlow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatMassFlowRate(SpeedNum);
-                    state.dataHVACMultiSpdHP->CompOffFlowRatio = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).HeatingSpeedRatio(SpeedNum);
+                if (mshp.LastMode == ModeOfOperation::HeatingMode) {
+                    state.dataHVACMultiSpdHP->CompOffMassFlow = mshp.HeatMassFlowRate(SpeedNum);
+                    state.dataHVACMultiSpdHP->CompOffFlowRatio = mshp.HeatingSpeedRatio(SpeedNum);
                 } else {
-                    state.dataHVACMultiSpdHP->CompOffMassFlow = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolMassFlowRate(SpeedNum);
-                    state.dataHVACMultiSpdHP->CompOffFlowRatio = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).CoolingSpeedRatio(SpeedNum);
+                    state.dataHVACMultiSpdHP->CompOffMassFlow = mshp.CoolMassFlowRate(SpeedNum);
+                    state.dataHVACMultiSpdHP->CompOffFlowRatio = mshp.CoolingSpeedRatio(SpeedNum);
                 }
             }
         }
@@ -4034,12 +3648,12 @@ namespace HVACMultiSpeedHeatPump {
         }
 
         //!!LKL Discrepancy with > 0
-        if (state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum).availSched->getCurrentVal() == 0.0) {
-            state.dataLoopNodes->Node(InletNode).MassFlowRate = 0.0;
+        if (mshp.availSched->getCurrentVal() == 0.0) {
+            s_node->Node(mshp.AirInletNode).MassFlowRate = 0.0;
             OnOffAirFlowRatio = 0.0;
         } else {
-            state.dataLoopNodes->Node(InletNode).MassFlowRate = AverageUnitMassFlow;
-            state.dataLoopNodes->Node(InletNode).MassFlowRateMaxAvail = AverageUnitMassFlow;
+            s_node->Node(mshp.AirInletNode).MassFlowRate = AverageUnitMassFlow;
+            s_node->Node(mshp.AirInletNode).MassFlowRateMaxAvail = AverageUnitMassFlow;
             if (AverageUnitMassFlow > 0.0) {
                 OnOffAirFlowRatio = state.dataHVACMultiSpdHP->CompOnMassFlow / AverageUnitMassFlow;
             } else {
@@ -4075,72 +3689,87 @@ namespace HVACMultiSpeedHeatPump {
         Real64 constexpr ErrTolerance(0.001); // convergence limit for hotwater coil
         int constexpr SolveMaxIter(50);
 
-        // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        Real64 QCoilActual;     // actual heating load met
-        Real64 mdot;            // heating coil steam or hot water mass flow rate
-        Real64 MinWaterFlow;    // coil minimum hot water mass flow rate, kg/s
-        Real64 MaxHotWaterFlow; // coil maximum hot water mass flow rate, kg/s
-        Real64 HotWaterMdot;    // actual hot water mass flow rate
-
-        int HeatCoilType;
-        int HeatCoilNum;
-        Real64 MaxCoilFluidFlow;
-        Real64 SteamCoilHeatingLoad;
-        int CoilControlNode;
-        int CoilOutletNode;
-        PlantLocation plantLoc{};
-
-        QCoilActual = 0.0;
+        Real64 QCoilActual = 0.0; // actual heating load met
 
-        auto &MSHeatPump = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
+        auto &mshp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
 
         if (present(PartLoadFrac)) {
-            HeatCoilType = MSHeatPump.HeatCoilType;
-            state.dataHVACMultiSpdHP->HeatCoilName = MSHeatPump.HeatCoilName;
-            HeatCoilNum = MSHeatPump.HeatCoilNum;
-            MaxCoilFluidFlow = MSHeatPump.MaxCoilFluidFlow;
-            CoilControlNode = MSHeatPump.CoilControlNode;
-            CoilOutletNode = MSHeatPump.CoilOutletNode;
-            plantLoc = MSHeatPump.plantLoc;
-        } else {
-            HeatCoilType = MSHeatPump.SuppHeatCoilType;
-            state.dataHVACMultiSpdHP->HeatCoilName = MSHeatPump.SuppHeatCoilName;
-            HeatCoilNum = MSHeatPump.SuppHeatCoilNum;
-            MaxCoilFluidFlow = MSHeatPump.MaxSuppCoilFluidFlow;
-            CoilControlNode = MSHeatPump.SuppCoilControlNode;
-            CoilOutletNode = MSHeatPump.SuppCoilOutletNode;
-            plantLoc = MSHeatPump.SuppPlantLoc;
-        }
-
-        MSHeatPump.HotWaterPlantLoc = plantLoc;
-        MSHeatPump.HotWaterCoilControlNode = CoilControlNode;
-        MSHeatPump.HotWaterCoilOutletNode = CoilOutletNode;
-        MSHeatPump.HotWaterCoilName = state.dataHVACMultiSpdHP->HeatCoilName;
-        MSHeatPump.HotWaterCoilNum = HeatCoilNum;
-
-        if (HeatingLoad > HVAC::SmallLoad) {
-
-            switch (HeatCoilType) {
-            case SuppHeatingCoilGas:
-            case SuppHeatingCoilElec: {
-                HeatingCoils::SimulateHeatingCoilComponents(
-                    state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatingLoad, HeatCoilNum, QCoilActual, true, fanOp);
-            } break;
-            case HVAC::Coil_HeatingWater: {
-                if (present(PartLoadFrac)) {
-                    MaxHotWaterFlow = MaxCoilFluidFlow * PartLoadFrac;
-                    PlantUtilities::SetComponentFlowRate(state, MaxHotWaterFlow, CoilControlNode, CoilOutletNode, plantLoc);
-                    WaterCoils::SimulateWaterCoilComponents(
-                        state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatCoilNum, QCoilActual, fanOp);
-                } else {
-                    MaxHotWaterFlow = MaxCoilFluidFlow;
-                    PlantUtilities::SetComponentFlowRate(state, MaxHotWaterFlow, CoilControlNode, CoilOutletNode, plantLoc);
+        
+            if (HeatingLoad > HVAC::SmallLoad) {
+
+                switch (mshp.heatCoilType) {
+                case HVAC::CoilType::HeatingGasOrOtherFuel:
+                case HVAC::CoilType::HeatingElectric: {
+                  HeatingCoils::SimulateHeatingCoilComponents(
+                      state, mshp.HeatCoilName, FirstHVACIteration, HeatingLoad, mshp.HeatCoilNum, QCoilActual, true, fanOp);
+                } break;
+                  
+                case HVAC::CoilType::HeatingWater: {
+                    Real64 MaxHotWaterFlow = mshp.HeatCoilMaxFluidFlow * PartLoadFrac;
+                    PlantUtilities::SetComponentFlowRate(state, MaxHotWaterFlow, mshp.HeatCoilControlNode, mshp.HeatCoilFluidOutletNode, mshp.HeatCoilPlantLoc);
+                    WaterCoils::SimulateWaterCoilComponents(state, mshp.HeatCoilName, FirstHVACIteration, mshp.HeatCoilNum, QCoilActual, fanOp);
+                } break;
+
+                case HVAC::CoilType::HeatingSteam: {
+                    Real64 mdot = mshp.HeatCoilMaxFluidFlow * PartLoadFrac;
+                    Real64 CoilHeatingLoad = HeatingLoad * PartLoadFrac;
+                    PlantUtilities::SetComponentFlowRate(state, mdot, mshp.HeatCoilControlNode, mshp.HeatCoilFluidOutletNode, mshp.HeatCoilPlantLoc);
+                    // simulate steam supplemental heating coil
+                    SteamCoils::SimulateSteamCoilComponents(
+                        state, mshp.HeatCoilName, FirstHVACIteration, mshp.HeatCoilNum, CoilHeatingLoad, QCoilActual, fanOp);
+                } break;
+                default:
+                  break;
+                }
+                
+            } else { // end of IF (HeatingLoad > SmallLoad) THEN
+              
+                switch (mshp.heatCoilType) {
+                case HVAC::CoilType::HeatingGasOrOtherFuel:
+                case HVAC::CoilType::HeatingElectric: {
+                    HeatingCoils::SimulateHeatingCoilComponents(
+                       state, mshp.HeatCoilName, FirstHVACIteration, HeatingLoad, mshp.HeatCoilNum, QCoilActual, true, fanOp);
+                } break;
+                  
+                case HVAC::CoilType::HeatingWater: {
+                    Real64 mdot = 0.0;
+                    PlantUtilities::SetComponentFlowRate(state, mdot, mshp.HeatCoilControlNode, mshp.HeatCoilFluidOutletNode, mshp.HeatCoilPlantLoc);
+                    WaterCoils::SimulateWaterCoilComponents(state, mshp.HeatCoilName, FirstHVACIteration, mshp.HeatCoilNum, QCoilActual, fanOp);
+                } break;
+                  
+                case HVAC::CoilType::HeatingSteam: {
+                    Real64 mdot = 0.0;
+                    PlantUtilities::SetComponentFlowRate(state, mdot, mshp.HeatCoilControlNode, mshp.HeatCoilFluidOutletNode, mshp.HeatCoilPlantLoc);
+                    // simulate the steam supplemental heating coil
+                    SteamCoils::SimulateSteamCoilComponents(
+                        state, mshp.HeatCoilName, FirstHVACIteration, mshp.HeatCoilNum, HeatingLoad, QCoilActual, fanOp);
+                } break;
+                default:
+                  break;
+                }
+            }
+            
+        } else { // !present(PartLoad)
+            if (HeatingLoad > HVAC::SmallLoad) {
+
+                switch (mshp.suppHeatCoilType) {
+                case HVAC::CoilType::HeatingGasOrOtherFuel:
+                case HVAC::CoilType::HeatingElectric: {
+                    HeatingCoils::SimulateHeatingCoilComponents(
+                        state, mshp.SuppHeatCoilName, FirstHVACIteration, HeatingLoad, mshp.SuppHeatCoilNum, QCoilActual, true, fanOp);
+                } break;
+                  
+                case HVAC::CoilType::HeatingWater: {
+                    Real64 MaxHotWaterFlow = mshp.SuppHeatCoilMaxFluidFlow;
+                    PlantUtilities::SetComponentFlowRate(
+                        state, MaxHotWaterFlow, mshp.SuppHeatCoilControlNode, mshp.SuppHeatCoilFluidOutletNode, mshp.SuppHeatCoilPlantLoc);
                     WaterCoils::SimulateWaterCoilComponents(
-                        state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatCoilNum, QCoilActual, fanOp);
+                        state, mshp.SuppHeatCoilName, FirstHVACIteration, mshp.SuppHeatCoilNum, QCoilActual, fanOp);
+
                     if (QCoilActual > (HeatingLoad + HVAC::SmallLoad)) {
                         // control water flow to obtain output matching HeatingLoad
                         int SolFlag = 0;
-                        MinWaterFlow = 0.0;
+                        Real64 MinWaterFlow = 0.0;
                         auto f = [&state, MSHeatPumpNum, FirstHVACIteration, HeatingLoad](Real64 const HWFlow) {
                             // Calculates residual function (QCoilActual - SupHeatCoilLoad) / SupHeatCoilLoad
                             // coil actual output depends on the hot water flow rate which is varied to minimize the residual.
@@ -4149,103 +3778,106 @@ namespace HVACMultiSpeedHeatPump {
                             Real64 mdot = HWFlow;
                             auto &hp = state.dataHVACMultiSpdHP->MSHeatPump(MSHeatPumpNum);
                             PlantUtilities::SetComponentFlowRate(
-                                state, mdot, hp.HotWaterCoilControlNode, hp.HotWaterCoilOutletNode, hp.HotWaterPlantLoc);
+                                state, mdot, hp.SuppHeatCoilControlNode, hp.SuppHeatCoilFluidOutletNode, hp.SuppHeatCoilPlantLoc);
                             // simulate the hot water supplemental heating coil
                             WaterCoils::SimulateWaterCoilComponents(
-                                state, hp.HotWaterCoilName, FirstHVACIteration, hp.HotWaterCoilNum, calcHeatingCoilLoad, hp.fanOp);
+                                 state, hp.SuppHeatCoilName, FirstHVACIteration, hp.SuppHeatCoilNum, calcHeatingCoilLoad, hp.fanOp);
                             if (targetHeatingCoilLoad != 0.0) {
                                 return (calcHeatingCoilLoad - targetHeatingCoilLoad) / targetHeatingCoilLoad;
                             } else { // Autodesk:Return Condition added to assure return value is set
                                 return 0.0;
                             }
                         };
+
+                        Real64 HotWaterMdot;
                         General::SolveRoot(state, ErrTolerance, SolveMaxIter, SolFlag, HotWaterMdot, f, MinWaterFlow, MaxHotWaterFlow);
                         if (SolFlag == -1) {
-                            if (MSHeatPump.HotWaterCoilMaxIterIndex == 0) {
+                            if (mshp.HotWaterCoilMaxIterIndex == 0) {
                                 ShowWarningMessage(state,
                                                    format("CalcNonDXHeatingCoils: Hot water coil control failed for {}=\"{}\"",
                                                           CurrentModuleObject,
-                                                          MSHeatPump.Name));
+                                                          mshp.Name));
                                 ShowContinueErrorTimeStamp(state, "");
                                 ShowContinueError(state,
                                                   format("  Iteration limit [{}] exceeded in calculating hot water mass flow rate", SolveMaxIter));
-                            }
+                                 }
                             ShowRecurringWarningErrorAtEnd(
-                                state,
-                                format("CalcNonDXHeatingCoils: Hot water coil control failed (iteration limit [{}]) for {}=\"{}",
-                                       SolveMaxIter,
-                                       CurrentModuleObject,
-                                       MSHeatPump.Name),
-                                MSHeatPump.HotWaterCoilMaxIterIndex);
+                                                           state,
+                                                           format("CalcNonDXHeatingCoils: Hot water coil control failed (iteration limit [{}]) for {}=\"{}",
+                                                                  SolveMaxIter,
+                                                                  CurrentModuleObject,
+                                                                  mshp.Name),
+                                                           mshp.HotWaterCoilMaxIterIndex);
                         } else if (SolFlag == -2) {
-                            if (MSHeatPump.HotWaterCoilMaxIterIndex2 == 0) {
-                                ShowWarningMessage(state,
-                                                   format("CalcNonDXHeatingCoils: Hot water coil control failed (maximum flow limits) for {}=\"{}\"",
-                                                          CurrentModuleObject,
-                                                          MSHeatPump.Name));
-                                ShowContinueErrorTimeStamp(state, "");
-                                ShowContinueError(state, "...Bad hot water maximum flow rate limits");
-                                ShowContinueError(state, format("...Given minimum water flow rate={:.3R} kg/s", MinWaterFlow));
-                                ShowContinueError(state, format("...Given maximum water flow rate={:.3R} kg/s", MaxHotWaterFlow));
+                            if (mshp.HotWaterCoilMaxIterIndex2 == 0) {
+                              ShowWarningMessage(state,
+                                                 format("CalcNonDXHeatingCoils: Hot water coil control failed (maximum flow limits) for {}=\"{}\"",
+                                                        CurrentModuleObject,
+                                                        mshp.Name));
+                              ShowContinueErrorTimeStamp(state, "");
+                              ShowContinueError(state, "...Bad hot water maximum flow rate limits");
+                              ShowContinueError(state, format("...Given minimum water flow rate={:.3R} kg/s", MinWaterFlow));
+                              ShowContinueError(state, format("...Given maximum water flow rate={:.3R} kg/s", MaxHotWaterFlow));
                             }
                             ShowRecurringWarningErrorAtEnd(state,
                                                            "CalcNonDXHeatingCoils: Hot water coil control failed (flow limits) for " +
-                                                               std::string{CurrentModuleObject} + "=\"" + MSHeatPump.Name + "\"",
-                                                           MSHeatPump.HotWaterCoilMaxIterIndex2,
+                                                           std::string{CurrentModuleObject} + "=\"" + mshp.Name + "\"",
+                                                           mshp.HotWaterCoilMaxIterIndex2,
                                                            MaxHotWaterFlow,
                                                            MinWaterFlow,
                                                            _,
                                                            "[kg/s]",
                                                            "[kg/s]");
-                        }
+                             }
                         // simulate hot water supplemental heating coil
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatCoilNum, QCoilActual, fanOp);
+                            state, mshp.SuppHeatCoilName, FirstHVACIteration, mshp.SuppHeatCoilNum, QCoilActual, fanOp);
                     }
+                } break;
+                
+                case HVAC::CoilType::HeatingSteam: {
+                    Real64 mdot = mshp.SuppHeatCoilMaxFluidFlow;
+                    Real64 SteamCoilHeatingLoad = HeatingLoad;
+                    PlantUtilities::SetComponentFlowRate(
+                        state, mdot, mshp.SuppHeatCoilControlNode, mshp.SuppHeatCoilFluidOutletNode, mshp.SuppHeatCoilPlantLoc);
+                    // simulate steam supplemental heating coil
+                    SteamCoils::SimulateSteamCoilComponents(
+                        state, mshp.SuppHeatCoilName, FirstHVACIteration, mshp.SuppHeatCoilNum, SteamCoilHeatingLoad, QCoilActual, fanOp);
+                } break;
+                default:
+                  break;
+                }
+                
+            } else { // end of IF (HeatingLoad > SmallLoad) THEN
+              
+                switch (mshp.suppHeatCoilType) {
+                case HVAC::CoilType::HeatingGasOrOtherFuel:
+                case HVAC::CoilType::HeatingElectric: {
+                    HeatingCoils::SimulateHeatingCoilComponents(
+                        state, mshp.SuppHeatCoilName, FirstHVACIteration, HeatingLoad, mshp.SuppHeatCoilNum, QCoilActual, true, fanOp);
+                } break;
+                  
+                case HVAC::CoilType::HeatingWater: {
+                    Real64 mdot = 0.0;
+                    PlantUtilities::SetComponentFlowRate(
+                        state, mdot, mshp.SuppHeatCoilControlNode, mshp.SuppHeatCoilFluidOutletNode, mshp.SuppHeatCoilPlantLoc);
+                    WaterCoils::SimulateWaterCoilComponents(state, mshp.SuppHeatCoilName, FirstHVACIteration, mshp.HeatCoilNum, QCoilActual, fanOp);
+                } break;
+                  
+                case HVAC::CoilType::HeatingSteam: {
+                    Real64 mdot = 0.0;
+                    PlantUtilities::SetComponentFlowRate(
+                        state, mdot, mshp.SuppHeatCoilControlNode, mshp.SuppHeatCoilFluidOutletNode, mshp.SuppHeatCoilPlantLoc);
+                    // simulate the steam supplemental heating coil
+                    SteamCoils::SimulateSteamCoilComponents(
+                        state, mshp.SuppHeatCoilName, FirstHVACIteration, mshp.SuppHeatCoilNum, HeatingLoad, QCoilActual, fanOp);
+                } break;
+                default:
+                  break;
                 }
-            } break;
-            case HVAC::Coil_HeatingSteam: {
-                if (present(PartLoadFrac)) {
-                    mdot = MSHeatPump.MaxCoilFluidFlow * PartLoadFrac;
-                    SteamCoilHeatingLoad = HeatingLoad * PartLoadFrac;
-                } else {
-                    mdot = MSHeatPump.MaxCoilFluidFlow;
-                    SteamCoilHeatingLoad = HeatingLoad;
-                }
-                PlantUtilities::SetComponentFlowRate(state, mdot, CoilControlNode, CoilOutletNode, plantLoc);
-                // simulate steam supplemental heating coil
-                SteamCoils::SimulateSteamCoilComponents(
-                    state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatCoilNum, SteamCoilHeatingLoad, QCoilActual, fanOp);
-            } break;
-            default:
-                break;
-            }
-
-        } else { // end of IF (HeatingLoad > SmallLoad) THEN
-
-            switch (HeatCoilType) {
-            case SuppHeatingCoilGas:
-            case SuppHeatingCoilElec: {
-                HeatingCoils::SimulateHeatingCoilComponents(
-                    state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatingLoad, HeatCoilNum, QCoilActual, true, fanOp);
-            } break;
-            case HVAC::Coil_HeatingWater: {
-                mdot = 0.0;
-                PlantUtilities::SetComponentFlowRate(state, mdot, CoilControlNode, CoilOutletNode, plantLoc);
-                WaterCoils::SimulateWaterCoilComponents(
-                    state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatCoilNum, QCoilActual, fanOp);
-            } break;
-            case HVAC::Coil_HeatingSteam: {
-                mdot = 0.0;
-                PlantUtilities::SetComponentFlowRate(state, mdot, CoilControlNode, CoilOutletNode, plantLoc);
-                // simulate the steam supplemental heating coil
-                SteamCoils::SimulateSteamCoilComponents(
-                    state, state.dataHVACMultiSpdHP->HeatCoilName, FirstHVACIteration, HeatCoilNum, HeatingLoad, QCoilActual, fanOp);
-            } break;
-            default:
-                break;
             }
         }
+
         HeatCoilLoadmet = QCoilActual;
     }
 
diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.hh b/src/EnergyPlus/HVACMultiSpeedHeatPump.hh
index fc524dba094..995d39e059a 100644
--- a/src/EnergyPlus/HVACMultiSpeedHeatPump.hh
+++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.hh
@@ -64,15 +64,6 @@ struct EnergyPlusData;
 
 namespace HVACMultiSpeedHeatPump {
 
-    // Heating coil types
-    int constexpr MultiSpeedHeatingCoil(1); // COIL:DX:MultiSpeed:Heating
-    // Cooling coil types
-    int constexpr MultiSpeedCoolingCoil(2); // COIL:DX:MultiSpeed:Cooling
-    // Supplymental heating coil types
-    int constexpr SuppHeatingCoilGas(1);  // Supplymental heating coil type: COIL:GAS:HEATING
-    int constexpr SuppHeatingCoilElec(2); // Supplymental heating coil type: COIL:ELECTRIC:HEATING
-    int constexpr SuppHeatingCoilRec(3);  // Supplymental heating coil type: COIL:ENGINEHEATRECOVERY:HEATING
-
     // Mode of operation
     enum class ModeOfOperation
     {
@@ -97,106 +88,111 @@ namespace HVACMultiSpeedHeatPump {
     {
         // Members
         // Some variables in this type are arrays (dimension=MaxSpeed) to support the number of speeds
-        std::string Name;                          // Name of the engine driven heat pump
-        Sched::Schedule *availSched = nullptr;     // availability schedule
-        int AirInletNodeNum;                       // Node number of the heat pump air inlet
-        int AirOutletNodeNum;                      // Node number of the heat pump air inlet
-        std::string AirInletNodeName;              // Node name of the heat pump air inlet
-        std::string AirOutletNodeName;             // Node name of the heat pump air outlet
-        int ControlZoneNum;                        // Controlling zone or thermostat location
-        int ZoneSequenceCoolingNum;                // Index to cooling sequence/priority for this zone
-        int ZoneSequenceHeatingNum;                // Index to heating sequence/priority for this zone
-        std::string ControlZoneName;               // Controlled zone name
-        int NodeNumOfControlledZone;               // Controlled zone node number
-        Real64 FlowFraction;                       // Fraction of the total volume flow that goes through the controlling zone
-        std::string FanName;                       // Name of supply air fan
-        HVAC::FanType fanType;                     // Supply fan type
-        int FanNum;                                // Supply fan number
-        HVAC::FanPlace fanPlace;                   // Supply air fan placement: 1 Blow through; 2 Draw through
-        int FanInletNode;                          // Fan Inlet node
-        int FanOutletNode;                         // Fan Outlet node
-        Real64 FanVolFlow;                         // Supply fan volumetric flow rate
+        std::string Name;                         // Name of the engine driven heat pump
+        Sched::Schedule *availSched = nullptr;    // availability schedule
+        int AirInletNode = 0;                     // Node number of the heat pump air inlet
+        int AirOutletNode = 0;                    // Node number of the heat pump air inlet
+        int ControlZoneNum;                       // Controlling zone or thermostat location
+        int ZoneSequenceCoolingNum;               // Index to cooling sequence/priority for this zone
+        int ZoneSequenceHeatingNum;               // Index to heating sequence/priority for this zone
+        std::string ControlZoneName;              // Controlled zone name
+        int NodeNumOfControlledZone = 0;          // Controlled zone node number
+        Real64 FlowFraction;                      // Fraction of the total volume flow that goes through the controlling zone
+        std::string FanName;                      // Name of supply air fan
+        HVAC::FanType fanType;                    // Supply fan type
+        int FanNum;                               // Supply fan number
+        HVAC::FanPlace fanPlace;                  // Supply air fan placement: 1 Blow through; 2 Draw through
+        int FanInletNode = 0;                     // Fan Inlet node
+        int FanOutletNode = 0;                    // Fan Outlet node
+        Real64 FanVolFlow;                        // Supply fan volumetric flow rate
+
         Sched::Schedule *fanOpModeSched = nullptr; // Supply air fan operating mode schedule
-        HVAC::FanOp fanOp = HVAC::FanOp::Invalid;  // mode of operation; 1=cycling fan, cycling compressor; 2=continuous fan, cycling compresor
-        std::string DXHeatCoilName;                // COIL:DX:MultiSpeed:Heating name
-        int HeatCoilType;                          // Heating coil type: 1 COIL:DX:MultiSpeed:Heating only
-        int HeatCoilNum;                           // Heating coil number
-        int DXHeatCoilIndex;                       // DX heating coil index number
-        std::string HeatCoilName;                  // Coil:Electric:MultiSpeed:Heating OR Coil:Gas:MultiSpeed:Heating name
-        int HeatCoilIndex;                         // heating coil index number (Coil:Electric:MultiSpeed:Heating OR Coil:Gas:MultiSpeed:Heating)
-        std::string DXCoolCoilName;                // COIL:DX:MultiSpeed:Cooling name
-        int CoolCoilType;                          // Cooling coil type: 1 COIL:DX:MultiSpeed:Cooling only
-        int DXCoolCoilIndex;                       // DX cooling coil index number
-        std::string SuppHeatCoilName;              // Supplymental heating coil name
-        int SuppHeatCoilType;                      // Supplymental heating coil type: 1 Gas; 2 Electric; 3 Recovery
-        int SuppHeatCoilNum;                       // Supplymental heating coil number
-        Real64 DesignSuppHeatingCapacity;          // Supplemental heating coil design capacity
-        Real64 SuppMaxAirTemp;                     // Maximum supply air temperature from supplemental heater
-        Real64 SuppMaxOATemp;                      // Maximum outdoor dry-bulb temperature for supplemental heater operation
-        Real64 AuxOnCyclePower;                    // Auxiliary On-Cycle Electric Power
-        Real64 AuxOffCyclePower;                   // Auxiliary Off-Cycle Electric Power
-        Real64 DesignHeatRecFlowRate;              // Design water volume flow rate through heat recovery loop [m3/s]
-        bool HeatRecActive;                        // True when entered Heat Rec Vol Flow Rate > 0
-        std::string HeatRecName;                   // heat recovery water inlet name
-        int HeatRecInletNodeNum;                   // Node number on heat recovery water inlet
-        int HeatRecOutletNodeNum;                  // Node number on heat recovery water outlet
-        Real64 MaxHeatRecOutletTemp;               // Maximum outlet water temperature for heat recovery
-        Real64 DesignHeatRecMassFlowRate;          // Design water mass flow rate through heat recovery loop [kg/s]
-        PlantLocation HRPlantLoc;                  // plant loop component for heat recovery
-        Real64 AuxElecPower;                       // Auxiliary Electric Power
-        Real64 IdleVolumeAirRate;                  // Supply air volumetric flow rate when no cooling or heating is needed
-        Real64 IdleMassFlowRate;                   // Supply air mass flow rate when no cooling or heating is needed
-        Real64 IdleSpeedRatio;                     // Fan speed ratio in idle mode
-        int NumOfSpeedCooling;                     // The number of speeds for cooling
-        int NumOfSpeedHeating;                     // The number of speeds for heating
-        Array1D<Real64> HeatVolumeFlowRate;        // Supply air volume flow rate during heating operation
-        Array1D<Real64> HeatMassFlowRate;          // Supply air mass flow rate during heating operation
-        Array1D<Real64> CoolVolumeFlowRate;        // Supply air volume flow rate during cooling operation
-        Array1D<Real64> CoolMassFlowRate;          // Supply air mass flow rate during cooling operation
-        Array1D<Real64> HeatingSpeedRatio;         // Fan speed ratio in heating mode
-        Array1D<Real64> CoolingSpeedRatio;         // Fan speed ratio in cooling mode
-        bool CheckFanFlow;                         // Supply airflow check
-        ModeOfOperation LastMode;                  // MSHP operation mode
-        ModeOfOperation HeatCoolMode;              // System operating mode (0 = floating, 1 = cooling, 2 = heating)
-        int AirLoopNumber;                         // Air loop served by the engine driven heat pump system
-        int NumControlledZones;                    // Number of controlled zones for this system
-        int ZoneInletNode;                         // Zone inlet node number in the controlled zone
-        Real64 CompPartLoadRatio;                  // Compressor part load ratio
-        Real64 FanPartLoadRatio;                   // Fan part load ratio
-        Real64 TotCoolEnergyRate;                  // Total cooling enertgy rate
-        Real64 TotHeatEnergyRate;                  // Total heating enertgy rate
-        Real64 SensCoolEnergyRate;                 // Sensible cooling enertgy rate
-        Real64 SensHeatEnergyRate;                 // Sensible heating enertgy rate
-        Real64 LatCoolEnergyRate;                  // Latent cooling enertgy rate
-        Real64 LatHeatEnergyRate;                  // Latent heating enertgy rate
-        Real64 ElecPower;                          // Electric power (fan + supplemental electric coil)
-        Real64 LoadMet;                            // met system load
-        Real64 HeatRecoveryRate;                   // Heat recovery rate [W]
-        Real64 HeatRecoveryInletTemp;              // Inlet temperature for heat recovery rate [C]
-        Real64 HeatRecoveryOutletTemp;             // Outlet temperature for heat recovery rate [C]
-        Real64 HeatRecoveryMassFlowRate;           // Mass flow rate for heat recovery rate [kg/s]
-        AirflowControl AirFlowControl;             // fan control mode, UseCompressorOnFlow or UseCompressorOffFlow
-        int ErrIndexCyc;                           // Error index at low speed
-        int ErrIndexVar;                           // Error index at high speed
-        Real64 LoadLoss;                           // Air distribution system loss
-        int SuppCoilAirInletNode;                  // air inlet node number of supplemental heating coil
-        int SuppCoilAirOutletNode;                 // air outlet node number of supplemental heating coil
-        int SuppHeatCoilType_Num;                  // Numeric Equivalent for Supplemental Heat Coil Type
-        int SuppHeatCoilIndex;                     // Index to supplemental heater
-        int SuppCoilControlNode;                   // control node for simple water and steam heating coil
-        Real64 MaxSuppCoilFluidFlow;               // water or steam mass flow rate for supplemental heating coil [kg/s]
-        int SuppCoilOutletNode;                    // outlet node for hot water and steam supplemental heating coil
-        int CoilAirInletNode;                      // air inlet node number of supplemental heating coil
-        int CoilControlNode;                       // control node for simple water and steam heating coil
-        Real64 MaxCoilFluidFlow;                   // water or steam mass flow rate for supplemental heating coil [kg/s]
-        int CoilOutletNode;                        // outlet node for hot water and steam supplemental heating coil
-        int HotWaterCoilControlNode;
-        int HotWaterCoilOutletNode;
-        std::string HotWaterCoilName;
-        int HotWaterCoilNum;
-        PlantLocation plantLoc;         // plant loop component location for hot water and steam heating coil
-        PlantLocation SuppPlantLoc;     // plant loop component location for hot water and steam supplemental heating coil
-        PlantLocation HotWaterPlantLoc; // plant loop component location for hot water and steam heating coil
+        HVAC::FanOp fanOp = HVAC::FanOp::Invalid; // mode of operation; 1=cycling fan, cycling compressor; 2=continuous fan, cycling compresor
+
+        std::string HeatCoilName;               // COIL:DX:MultiSpeed:Heating name
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;
+        int HeatCoilNum = 0;                        // heating coil index (Coil:Electric:MultiSpeed:Heating OR Coil:Gas:MultiSpeed:Heating)
+        PlantLocation HeatCoilPlantLoc = {};         // plant loop component location for hot water and steam heating coil
+
+        int HeatCoilAirInletNode = 0;
+        int HeatCoilAirOutletNode = 0;
+        int HeatCoilFluidOutletNode = 0;
+        int HeatCoilControlNode = 0;                      // control node for simple water and steam heating coil
+
+        Real64 HeatCoilMaxVolFlowRate = 0.0;
+        Real64 HeatCoilMaxFluidFlow = 0.0; 
+      
+        std::string CoolCoilName;               // COIL:DX:MultiSpeed:Cooling name
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;                         // Cooling coil type: 1 COIL:DX:MultiSpeed:Cooling only
+        int CoolCoilNum = 0;                      // DX cooling coil index number
+
+        int CoolCoilAirInletNode = 0;
+        int CoolCoilAirOutletNode = 0;
+      
+        std::string SuppHeatCoilName;             // Supplymental heating coil name
+        HVAC::CoilType suppHeatCoilType = HVAC::CoilType::Invalid; // Supplemental heating coil types: 1 Gas; 2 Electric; 3 Recovery
+        int SuppHeatCoilNum = 0;                      // Supplemental heating coil number
+        PlantLocation SuppHeatCoilPlantLoc = {};     // plant loop component location for hot water and steam supplemental heating coil
+
+        int SuppHeatCoilAirInletNode = 0;                 // air inlet node number of supplemental heating coil
+        int SuppHeatCoilAirOutletNode = 0;                // air outlet node number of supplemental heating coil
+        int SuppHeatCoilControlNode = 0;                  // control node for simple water and steam heating coil
+        int SuppHeatCoilFluidOutletNode = 0;                   // outlet node for hot water and steam supplemental heating coil
+
+        Real64 SuppHeatCoilMaxVolFlowRate = 0.0;
+        Real64 SuppHeatCoilMaxFluidFlow = 0.0;
+      
+        Real64 DesignSuppHeatingCapacity;         // Supplemental heating coil design capacity
+        Real64 SuppMaxAirTemp;                    // Maximum supply air temperature from supplemental heater
+        Real64 SuppMaxOATemp;                     // Maximum outdoor dry-bulb temperature for supplemental heater operation
+        Real64 AuxOnCyclePower;                   // Auxiliary On-Cycle Electric Power
+        Real64 AuxOffCyclePower;                  // Auxiliary Off-Cycle Electric Power
+        Real64 DesignHeatRecFlowRate;             // Design water volume flow rate through heat recovery loop [m3/s]
+        bool HeatRecActive;                       // True when entered Heat Rec Vol Flow Rate > 0
+        std::string HeatRecName;                  // heat recovery water inlet name
+        int HeatRecFluidInletNode = 0;                  // Node number on heat recovery water inlet
+        int HeatRecFluidOutletNode = 0;                 // Node number on heat recovery water outlet
+        Real64 MaxHeatRecOutletTemp;              // Maximum outlet water temperature for heat recovery
+        Real64 DesignHeatRecMassFlowRate;         // Design water mass flow rate through heat recovery loop [kg/s]
+        PlantLocation HRPlantLoc;                 // plant loop component for heat recovery
+        Real64 AuxElecPower;                      // Auxiliary Electric Power
+        Real64 IdleVolumeAirRate;                 // Supply air volumetric flow rate when no cooling or heating is needed
+        Real64 IdleMassFlowRate;                  // Supply air mass flow rate when no cooling or heating is needed
+        Real64 IdleSpeedRatio;                    // Fan speed ratio in idle mode
+        int NumOfSpeedCooling;                    // The number of speeds for cooling
+        int NumOfSpeedHeating;                    // The number of speeds for heating
+        Array1D<Real64> HeatVolumeFlowRate;       // Supply air volume flow rate during heating operation
+        Array1D<Real64> HeatMassFlowRate;         // Supply air mass flow rate during heating operation
+        Array1D<Real64> CoolVolumeFlowRate;       // Supply air volume flow rate during cooling operation
+        Array1D<Real64> CoolMassFlowRate;         // Supply air mass flow rate during cooling operation
+        Array1D<Real64> HeatingSpeedRatio;        // Fan speed ratio in heating mode
+        Array1D<Real64> CoolingSpeedRatio;        // Fan speed ratio in cooling mode
+        bool CheckFanFlow;                        // Supply airflow check
+        ModeOfOperation LastMode;                 // MSHP operation mode
+        ModeOfOperation HeatCoolMode;             // System operating mode (0 = floating, 1 = cooling, 2 = heating)
+        int AirLoopNumber;                        // Air loop served by the engine driven heat pump system
+        int NumControlledZones;                   // Number of controlled zones for this system
+        int ZoneInletNode = 0;                        // Zone inlet node number in the controlled zone
+        Real64 CompPartLoadRatio;                 // Compressor part load ratio
+        Real64 FanPartLoadRatio;                  // Fan part load ratio
+        Real64 TotCoolEnergyRate;                 // Total cooling enertgy rate
+        Real64 TotHeatEnergyRate;                 // Total heating enertgy rate
+        Real64 SensCoolEnergyRate;                // Sensible cooling enertgy rate
+        Real64 SensHeatEnergyRate;                // Sensible heating enertgy rate
+        Real64 LatCoolEnergyRate;                 // Latent cooling enertgy rate
+        Real64 LatHeatEnergyRate;                 // Latent heating enertgy rate
+        Real64 ElecPower;                         // Electric power (fan + supplemental electric coil)
+        Real64 LoadMet;                           // met system load
+        Real64 HeatRecoveryRate;                  // Heat recovery rate [W]
+        Real64 HeatRecoveryInletTemp;             // Inlet temperature for heat recovery rate [C]
+        Real64 HeatRecoveryOutletTemp;            // Outlet temperature for heat recovery rate [C]
+        Real64 HeatRecoveryMassFlowRate;          // Mass flow rate for heat recovery rate [kg/s]
+        AirflowControl AirFlowControl;            // fan control mode, UseCompressorOnFlow or UseCompressorOffFlow
+        int ErrIndexCyc;                          // Error index at low speed
+        int ErrIndexVar;                          // Error index at high speed
+        Real64 LoadLoss;                          // Air distribution system loss
+        Real64 MaxSuppHeatCoilFluidFlow;              // water or steam mass flow rate for supplemental heating coil [kg/s]
+      
         int HotWaterCoilMaxIterIndex;   // Index to recurring warning message
         int HotWaterCoilMaxIterIndex2;  // Index to recurring warning message
         int StageNum;                   // Stage number specified by staged thermostat
@@ -221,21 +217,19 @@ namespace HVACMultiSpeedHeatPump {
 
         // Default Constructor
         MSHeatPumpData()
-            : AirInletNodeNum(0), AirOutletNodeNum(0), ControlZoneNum(0), ZoneSequenceCoolingNum(0), ZoneSequenceHeatingNum(0),
-              NodeNumOfControlledZone(0), FlowFraction(0.0), fanType(HVAC::FanType::Invalid), FanNum(0), fanPlace(HVAC::FanPlace::Invalid),
-              FanInletNode(0), FanOutletNode(0), FanVolFlow(0.0), HeatCoilType(0), HeatCoilNum(0), DXHeatCoilIndex(0), HeatCoilIndex(0),
-              CoolCoilType(0), DXCoolCoilIndex(0), SuppHeatCoilType(0), SuppHeatCoilNum(0), DesignSuppHeatingCapacity(0.0), SuppMaxAirTemp(0.0),
-              SuppMaxOATemp(0.0), AuxOnCyclePower(0.0), AuxOffCyclePower(0.0), DesignHeatRecFlowRate(0.0), HeatRecActive(false),
-              HeatRecInletNodeNum(0), HeatRecOutletNodeNum(0), MaxHeatRecOutletTemp(0.0), DesignHeatRecMassFlowRate(0.0), HRPlantLoc{},
+            : ControlZoneNum(0), ZoneSequenceCoolingNum(0), ZoneSequenceHeatingNum(0),
+              FlowFraction(0.0), fanType(HVAC::FanType::Invalid), FanNum(0), fanPlace(HVAC::FanPlace::Invalid),
+              FanVolFlow(0.0),
+              DesignSuppHeatingCapacity(0.0),
+              SuppMaxAirTemp(0.0), SuppMaxOATemp(0.0), AuxOnCyclePower(0.0), AuxOffCyclePower(0.0), DesignHeatRecFlowRate(0.0), HeatRecActive(false),
+              MaxHeatRecOutletTemp(0.0), DesignHeatRecMassFlowRate(0.0), HRPlantLoc{},
               AuxElecPower(0.0), IdleVolumeAirRate(0.0), IdleMassFlowRate(0.0), IdleSpeedRatio(0.0), NumOfSpeedCooling(0), NumOfSpeedHeating(0),
               CheckFanFlow(true), LastMode(ModeOfOperation::Invalid), HeatCoolMode(ModeOfOperation::Invalid), AirLoopNumber(0), NumControlledZones(0),
-              ZoneInletNode(0), CompPartLoadRatio(0.0), FanPartLoadRatio(0.0), TotCoolEnergyRate(0.0), TotHeatEnergyRate(0.0),
+              CompPartLoadRatio(0.0), FanPartLoadRatio(0.0), TotCoolEnergyRate(0.0), TotHeatEnergyRate(0.0),
               SensCoolEnergyRate(0.0), SensHeatEnergyRate(0.0), LatCoolEnergyRate(0.0), LatHeatEnergyRate(0.0), ElecPower(0.0), LoadMet(0.0),
               HeatRecoveryRate(0.0), HeatRecoveryInletTemp(0.0), HeatRecoveryOutletTemp(0.0), HeatRecoveryMassFlowRate(0.0),
-              AirFlowControl(AirflowControl::Invalid), ErrIndexCyc(0), ErrIndexVar(0), LoadLoss(0.0), SuppCoilAirInletNode(0),
-              SuppCoilAirOutletNode(0), SuppHeatCoilType_Num(0), SuppHeatCoilIndex(0), SuppCoilControlNode(0), MaxSuppCoilFluidFlow(0.0),
-              SuppCoilOutletNode(0), CoilAirInletNode(0), CoilControlNode(0), MaxCoilFluidFlow(0.0), CoilOutletNode(0),
-              HotWaterCoilControlNode(0), plantLoc{}, SuppPlantLoc{}, HotWaterPlantLoc{}, HotWaterCoilMaxIterIndex(0), HotWaterCoilMaxIterIndex2(0),
+              AirFlowControl(AirflowControl::Invalid), ErrIndexCyc(0), ErrIndexVar(0), LoadLoss(0.0), 
+              HotWaterCoilMaxIterIndex(0), HotWaterCoilMaxIterIndex2(0),
               StageNum(0), Staged(false), CoolCountAvail(0), CoolIndexAvail(0), HeatCountAvail(0), HeatIndexAvail(0), FirstPass(true),
               MinOATCompressorCooling(0.0), MinOATCompressorHeating(0.0), MyEnvrnFlag(true), MySizeFlag(true), MyCheckFlag(true),
               MyFlowFracFlag(true), MyPlantScantFlag(true), MyStagedFlag(true), EMSOverrideCoilSpeedNumOn(false), EMSOverrideCoilSpeedNumValue(0.0),
@@ -390,9 +384,9 @@ struct HVACMultiSpeedHeatPumpData : BaseGlobalStruct
 
     int NumMSHeatPumps = 0;     // Number of multi speed heat pumps
     int AirLoopPass = 0;        // Number of air loop pass
-    Real64 TempSteamIn = 100.0; // steam coil steam inlet temperature
-
     std::string CurrentModuleObject; // Object type for getting and error messages
+
+    // What is the point of all of these shared state variables?
     Real64 CompOnMassFlow = 0.0;     // System air mass flow rate w/ compressor ON
     Real64 CompOffMassFlow = 0.0;    // System air mass flow rate w/ compressor OFF
     Real64 CompOnFlowRatio = 0.0;    // fan flow ratio when coil on
@@ -414,8 +408,6 @@ struct HVACMultiSpeedHeatPumpData : BaseGlobalStruct
     int ErrCountCyc = 0;           // Counter used to minimize the occurrence of output warnings
     int ErrCountVar = 0;           // Counter used to minimize the occurrence of output warnings
 
-    std::string HeatCoilName; // TODO: What's the best plan here?
-
     void init_constant_state([[maybe_unused]] EnergyPlusData &state) override
     {
     }
@@ -428,7 +420,6 @@ struct HVACMultiSpeedHeatPumpData : BaseGlobalStruct
     {
         this->NumMSHeatPumps = 0;
         this->AirLoopPass = 0;
-        this->TempSteamIn = 100.0;
         this->CurrentModuleObject = "";
         this->CompOnMassFlow = 0.0;
         this->CompOffMassFlow = 0.0;
@@ -445,7 +436,6 @@ struct HVACMultiSpeedHeatPumpData : BaseGlobalStruct
         this->FlowFracFlagReady = true;
         this->ErrCountCyc = 0;
         this->ErrCountVar = 0;
-        this->HeatCoilName = "";
     }
 };
 
diff --git a/src/EnergyPlus/HVACSingleDuctInduc.cc b/src/EnergyPlus/HVACSingleDuctInduc.cc
index bae7dd26852..969c4f2ab97 100644
--- a/src/EnergyPlus/HVACSingleDuctInduc.cc
+++ b/src/EnergyPlus/HVACSingleDuctInduc.cc
@@ -248,23 +248,25 @@ namespace HVACSingleDuctInduc {
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
 
             int IUNum = IUIndex;
+            auto &indUnit = state.dataHVACSingleDuctInduc->IndUnit(IUNum);
+            
             Util::IsNameEmpty(state, Alphas(1), CurrentModuleObject, ErrorsFound);
 
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name = Alphas(1);
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType = CurrentModuleObject;
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType_Num = SingleDuct_CV::FourPipeInduc;
+            indUnit.Name = Alphas(1);
+            indUnit.UnitType = CurrentModuleObject;
+            indUnit.UnitType_Num = SingleDuct_CV::FourPipeInduc;
 
             if (lAlphaBlanks(2)) {
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((state.dataHVACSingleDuctInduc->IndUnit(IUNum).availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                indUnit.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((indUnit.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
                 ErrorsFound = true;
             }
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow = Numbers(1);
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio = Numbers(2);
-            if (lNumericBlanks(2)) state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio = 2.5;
+            indUnit.MaxTotAirVolFlow = Numbers(1);
+            indUnit.InducRatio = Numbers(2);
+            if (lNumericBlanks(2)) indUnit.InducRatio = 2.5;
 
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).PriAirInNode =
+            indUnit.PriAirInNode =
                 GetOnlySingleNode(state,
                                   Alphas(3),
                                   ErrorsFound,
@@ -275,7 +277,7 @@ namespace HVACSingleDuctInduc {
                                   NodeInputManager::CompFluidStream::Primary,
                                   DataLoopNode::ObjectIsParent,
                                   cAlphaFields(3));
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).SecAirInNode =
+            indUnit.SecAirInNode =
                 GetOnlySingleNode(state,
                                   Alphas(4),
                                   ErrorsFound,
@@ -286,7 +288,7 @@ namespace HVACSingleDuctInduc {
                                   NodeInputManager::CompFluidStream::Primary,
                                   DataLoopNode::ObjectIsParent,
                                   cAlphaFields(4));
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode =
+            indUnit.OutAirNode =
                 GetOnlySingleNode(state,
                                   Alphas(5),
                                   ErrorsFound,
@@ -298,98 +300,104 @@ namespace HVACSingleDuctInduc {
                                   DataLoopNode::ObjectIsParent,
                                   cAlphaFields(5));
 
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoilType = Alphas(6); // type (key) of heating coil
-            if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoilType, "Coil:Heating:Water")) {
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).HeatingCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+            indUnit.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(6))); 
+            if (indUnit.heatCoilType != HVAC::CoilType::HeatingWater) {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(6), Alphas(6));
+                ErrorsFound = true;
+            } else {
+                indUnit.heatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
             }
 
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil = Alphas(7); // name of heating coil object
-            bool IsNotOK = false;
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWControlNode = WaterCoils::GetCoilWaterInletNode(
-                state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoilType, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil, IsNotOK);
-            if (IsNotOK) {
-                ShowContinueError(state, format("In {} = {}", CurrentModuleObject, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
-                ShowContinueError(state, "..Only Coil:Heating:Water is allowed.");
+            indUnit.heatCoilName = Alphas(7); // name of heating coil object
+            indUnit.heatCoilNum = WaterCoils::GetCoilIndex(state, indUnit.heatCoilName);
+            if (indUnit.heatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(7), indUnit.heatCoilName);
                 ErrorsFound = true;
+            } else { 
+                indUnit.HWControlNode = WaterCoils::GetCoilWaterInletNode(state, indUnit.heatCoilNum);
             }
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow = Numbers(3);
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinVolHotWaterFlow = Numbers(4);
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).HotControlOffset = Numbers(5);
+            
+            indUnit.MaxVolHotWaterFlow = Numbers(3);
+            indUnit.MinVolHotWaterFlow = Numbers(4);
+            indUnit.HotControlOffset = Numbers(5);
 
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType = Alphas(8); // type (key) of cooling coil
+            indUnit.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(8)));
 
-            if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType, "Coil:Cooling:Water")) {
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).CoolingCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-            } else if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType, "Coil:Cooling:Water:DetailedGeometry")) {
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).CoolingCoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+            if (indUnit.coolCoilType == HVAC::CoilType::CoolingWater) {
+                indUnit.coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+            } else if (indUnit.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
+                indUnit.coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+            } else {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(8), Alphas(8));
+                ErrorsFound = true;
             }
 
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil = Alphas(9); // name of cooling coil object
-            IsNotOK = false;
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWControlNode = WaterCoils::GetCoilWaterInletNode(
-                state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil, IsNotOK);
-            if (IsNotOK) {
-                ShowContinueError(state, format("In {} = {}", CurrentModuleObject, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
-                ShowContinueError(state, "..Only Coil:Cooling:Water or Coil:Cooling:Water:DetailedGeometry is allowed.");
+            indUnit.coolCoilName = Alphas(9); // name of cooling coil object
+            indUnit.coolCoilNum = WaterCoils::GetCoilIndex(state, indUnit.coolCoilName);
+            if (indUnit.coolCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(9), indUnit.coolCoilName);
                 ErrorsFound = true;
+            } else {
+                indUnit.CWControlNode = WaterCoils::GetCoilWaterInletNode(state, indUnit.coolCoilNum);
             }
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow = Numbers(6);
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinVolColdWaterFlow = Numbers(7);
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).ColdControlOffset = Numbers(8);
+
+            indUnit.MaxVolColdWaterFlow = Numbers(6);
+            indUnit.MinVolColdWaterFlow = Numbers(7);
+            indUnit.ColdControlOffset = Numbers(8);
 
             // Get the Zone Mixer name and check that it is OK
             bool errFlag = false;
-            state.dataHVACSingleDuctInduc->IndUnit(IUNum).MixerName = Alphas(10);
+            indUnit.MixerName = Alphas(10);
             MixerComponent::GetZoneMixerIndex(state,
-                                              state.dataHVACSingleDuctInduc->IndUnit(IUNum).MixerName,
-                                              state.dataHVACSingleDuctInduc->IndUnit(IUNum).Mixer_Num,
+                                              indUnit.MixerName,
+                                              indUnit.Mixer_Num,
                                               errFlag,
                                               CurrentModuleObject);
             if (errFlag) {
-                ShowContinueError(state, format("...specified in {} = {}", CurrentModuleObject, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                ShowContinueError(state, format("...specified in {} = {}", CurrentModuleObject, indUnit.Name));
                 ErrorsFound = true;
             }
 
             // Add heating coil to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoilType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil,
+                                                 indUnit.UnitType,
+                                                 indUnit.Name,
+                                                 HVAC::coilTypeNames[(int)indUnit.heatCoilType],
+                                                 indUnit.heatCoilName,
                                                  Alphas(4),
                                                  "UNDEFINED");
             // Add cooling coil to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil,
+                                                 indUnit.UnitType,
+                                                 indUnit.Name,
+                                                 HVAC::coilTypeNames[(int)indUnit.coolCoilType],
+                                                 indUnit.coolCoilName,
                                                  "UNDEFINED",
                                                  "UNDEFINED");
 
             // Register component set data
             BranchNodeConnections::TestCompSet(state,
-                                               state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                               state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
-                                               state.dataLoopNodes->NodeID(state.dataHVACSingleDuctInduc->IndUnit(IUNum).PriAirInNode),
-                                               state.dataLoopNodes->NodeID(state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode),
+                                               indUnit.UnitType,
+                                               indUnit.Name,
+                                               state.dataLoopNodes->NodeID(indUnit.PriAirInNode),
+                                               state.dataLoopNodes->NodeID(indUnit.OutAirNode),
                                                "Air Nodes");
 
             for (int ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-                if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                    state.dataHVACSingleDuctInduc->IndUnit(IUNum).ADUNum = ADUNum;
+                if (indUnit.OutAirNode == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                    indUnit.ADUNum = ADUNum;
                 }
             }
             // one assumes if there isn't one assigned, it's an error?
-            if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).ADUNum == 0) {
+            if (indUnit.ADUNum == 0) {
                 ShowSevereError(state,
                                 format("{}No matching Air Distribution Unit, for Unit = [{},{}].",
                                        RoutineName,
-                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                       indUnit.UnitType,
+                                       indUnit.Name));
                 ShowContinueError(
                     state,
-                    format("...should have outlet node={}", state.dataLoopNodes->NodeID(state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode)));
+                    format("...should have outlet node={}", state.dataLoopNodes->NodeID(indUnit.OutAirNode)));
                 ErrorsFound = true;
             } else {
                 // Fill the Zone Equipment data with the supply air inlet node number of this unit.
@@ -399,27 +407,27 @@ namespace HVACSingleDuctInduc {
 
                     if (!zoneEquipConfig.IsControlled) continue;
                     for (int SupAirIn = 1; SupAirIn <= zoneEquipConfig.NumInletNodes; ++SupAirIn) {
-                        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode == zoneEquipConfig.InletNode(SupAirIn)) {
+                        if (indUnit.OutAirNode == zoneEquipConfig.InletNode(SupAirIn)) {
                             if (zoneEquipConfig.AirDistUnitCool(SupAirIn).OutNode > 0) {
                                 ShowSevereError(state, "Error in connecting a terminal unit to a zone");
                                 ShowContinueError(state,
                                                   format("{} already connects to another zone",
-                                                         state.dataLoopNodes->NodeID(state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode)));
+                                                         state.dataLoopNodes->NodeID(indUnit.OutAirNode)));
                                 ShowContinueError(state,
                                                   format("Occurs for terminal unit {} = {}",
-                                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                         indUnit.UnitType,
+                                                         indUnit.Name));
                                 ShowContinueError(state, "Check terminal unit node names for errors");
                                 ErrorsFound = true;
                             } else {
-                                zoneEquipConfig.AirDistUnitCool(SupAirIn).InNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).PriAirInNode;
-                                zoneEquipConfig.AirDistUnitCool(SupAirIn).OutNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode;
-                                state.dataDefineEquipment->AirDistUnit(state.dataHVACSingleDuctInduc->IndUnit(IUNum).ADUNum).TermUnitSizingNum =
+                                zoneEquipConfig.AirDistUnitCool(SupAirIn).InNode = indUnit.PriAirInNode;
+                                zoneEquipConfig.AirDistUnitCool(SupAirIn).OutNode = indUnit.OutAirNode;
+                                state.dataDefineEquipment->AirDistUnit(indUnit.ADUNum).TermUnitSizingNum =
                                     zoneEquipConfig.AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                                state.dataDefineEquipment->AirDistUnit(state.dataHVACSingleDuctInduc->IndUnit(IUNum).ADUNum).ZoneEqNum = CtrlZone;
-                                state.dataHVACSingleDuctInduc->IndUnit(IUNum).CtrlZoneNum = CtrlZone;
+                                state.dataDefineEquipment->AirDistUnit(indUnit.ADUNum).ZoneEqNum = CtrlZone;
+                                indUnit.CtrlZoneNum = CtrlZone;
                             }
-                            state.dataHVACSingleDuctInduc->IndUnit(IUNum).CtrlZoneInNodeIndex = SupAirIn;
+                            indUnit.CtrlZoneInNodeIndex = SupAirIn;
                             AirNodeFound = true;
                             break;
                         }
@@ -428,7 +436,7 @@ namespace HVACSingleDuctInduc {
                 if (!AirNodeFound) {
                     ShowSevereError(
                         state,
-                        format("The outlet air node from the {} = {}", CurrentModuleObject, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                        format("The outlet air node from the {} = {}", CurrentModuleObject, indUnit.Name));
                     ShowContinueError(state, format("did not have a matching Zone Equipment Inlet Node, Node ={}", Alphas(3)));
                     ErrorsFound = true;
                 }
@@ -437,10 +445,10 @@ namespace HVACSingleDuctInduc {
             SetupOutputVariable(state,
                                 "Zone Air Terminal Outdoor Air Volume Flow Rate",
                                 Constant::Units::m3_s,
-                                state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutdoorAirFlowRate,
+                                indUnit.OutdoorAirFlowRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name);
+                                indUnit.Name);
         }
 
         Alphas.deallocate();
@@ -496,14 +504,16 @@ namespace HVACSingleDuctInduc {
             state.dataHVACSingleDuctInduc->MyOneTimeFlag = false;
         }
 
+        auto &indUnit = state.dataHVACSingleDuctInduc->IndUnit(IUNum);
+        
         if (state.dataHVACSingleDuctInduc->MyPlantScanFlag(IUNum) && allocated(state.dataPlnt->PlantLoop)) {
             bool errFlag = false;
-            if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).HeatingCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+            if (indUnit.heatCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
                 errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil,
-                                                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).HeatingCoilType,
-                                                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc,
+                                                        indUnit.heatCoilName,
+                                                        indUnit.heatCoilPlantType,
+                                                        indUnit.HWPlantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -514,16 +524,16 @@ namespace HVACSingleDuctInduc {
             if (errFlag) {
                 ShowContinueError(state,
                                   format("Reference Unit=\"{}\", type={}",
-                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
-                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType));
+                                         indUnit.Name,
+                                         indUnit.UnitType));
             }
-            if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).CoolingCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling ||
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).CoolingCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
+            if (indUnit.coolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling ||
+                indUnit.coolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
                 errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil,
-                                                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).CoolingCoilType,
-                                                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc,
+                                                        indUnit.coolCoilName,
+                                                        indUnit.coolCoilPlantType,
+                                                        indUnit.CWPlantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -534,8 +544,8 @@ namespace HVACSingleDuctInduc {
             if (errFlag) {
                 ShowContinueError(state,
                                   format("Reference Unit=\"{}\", type={}",
-                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
-                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType));
+                                         indUnit.Name,
+                                         indUnit.UnitType));
                 ShowFatalError(state, "InitIndUnit: Program terminated for previous conditions.");
             }
             state.dataHVACSingleDuctInduc->MyPlantScanFlag(IUNum) = false;
@@ -546,17 +556,12 @@ namespace HVACSingleDuctInduc {
         if (state.dataHVACSingleDuctInduc->MyAirDistInitFlag(IUNum)) {
             // save the induction ratio in the term unit sizing array for use in the system sizing calculation
             if (state.dataSize->CurTermUnitSizingNum > 0) {
-                state.dataSize->TermUnitSizing(state.dataSize->CurTermUnitSizingNum).InducRat =
-                    state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio;
+                state.dataSize->TermUnitSizing(state.dataSize->CurTermUnitSizingNum).InducRat = indUnit.InducRatio;
             }
-            if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).AirLoopNum == 0) {
-                if ((state.dataHVACSingleDuctInduc->IndUnit(IUNum).CtrlZoneNum > 0) &&
-                    (state.dataHVACSingleDuctInduc->IndUnit(IUNum).CtrlZoneInNodeIndex > 0)) {
-                    state.dataHVACSingleDuctInduc->IndUnit(IUNum).AirLoopNum =
-                        state.dataZoneEquip->ZoneEquipConfig(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CtrlZoneNum)
-                            .InletNodeAirLoopNum(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CtrlZoneInNodeIndex);
-                    state.dataDefineEquipment->AirDistUnit(state.dataHVACSingleDuctInduc->IndUnit(IUNum).ADUNum).AirLoopNum =
-                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).AirLoopNum;
+            if (indUnit.AirLoopNum == 0) {
+                if ((indUnit.CtrlZoneNum > 0) && (indUnit.CtrlZoneInNodeIndex > 0)) {
+                    indUnit.AirLoopNum = state.dataZoneEquip->ZoneEquipConfig(indUnit.CtrlZoneNum).InletNodeAirLoopNum(indUnit.CtrlZoneInNodeIndex);
+                    state.dataDefineEquipment->AirDistUnit(indUnit.ADUNum).AirLoopNum = indUnit.AirLoopNum;
                 }
             } else {
                 state.dataHVACSingleDuctInduc->MyAirDistInitFlag(IUNum) = false;
@@ -591,56 +596,56 @@ namespace HVACSingleDuctInduc {
         // Do the Begin Environment initializations
         if (state.dataGlobal->BeginEnvrnFlag && state.dataHVACSingleDuctInduc->MyEnvrnFlag(IUNum)) {
             RhoAir = state.dataEnvrn->StdRhoAir;
-            PriNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).PriAirInNode;
-            SecNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).SecAirInNode;
-            int OutletNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode;
-            IndRat = state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio;
+            PriNode = indUnit.PriAirInNode;
+            SecNode = indUnit.SecAirInNode;
+            int OutletNode = indUnit.OutAirNode;
+            IndRat = indUnit.InducRatio;
             // set the mass flow rates from the input volume flow rates
-            if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType, "AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction")) {
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirMassFlow =
-                    RhoAir * state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow;
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxPriAirMassFlow =
-                    state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirMassFlow / (1.0 + IndRat);
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxSecAirMassFlow =
-                    IndRat * state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirMassFlow / (1.0 + IndRat);
-                state.dataLoopNodes->Node(PriNode).MassFlowRateMax = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxPriAirMassFlow;
-                state.dataLoopNodes->Node(PriNode).MassFlowRateMin = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxPriAirMassFlow;
-                state.dataLoopNodes->Node(SecNode).MassFlowRateMax = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxSecAirMassFlow;
-                state.dataLoopNodes->Node(SecNode).MassFlowRateMin = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxSecAirMassFlow;
-                state.dataLoopNodes->Node(OutletNode).MassFlowRateMax = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirMassFlow;
+            if (Util::SameString(indUnit.UnitType, "AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction")) {
+                indUnit.MaxTotAirMassFlow =
+                    RhoAir * indUnit.MaxTotAirVolFlow;
+                indUnit.MaxPriAirMassFlow =
+                    indUnit.MaxTotAirMassFlow / (1.0 + IndRat);
+                indUnit.MaxSecAirMassFlow =
+                    IndRat * indUnit.MaxTotAirMassFlow / (1.0 + IndRat);
+                state.dataLoopNodes->Node(PriNode).MassFlowRateMax = indUnit.MaxPriAirMassFlow;
+                state.dataLoopNodes->Node(PriNode).MassFlowRateMin = indUnit.MaxPriAirMassFlow;
+                state.dataLoopNodes->Node(SecNode).MassFlowRateMax = indUnit.MaxSecAirMassFlow;
+                state.dataLoopNodes->Node(SecNode).MassFlowRateMin = indUnit.MaxSecAirMassFlow;
+                state.dataLoopNodes->Node(OutletNode).MassFlowRateMax = indUnit.MaxTotAirMassFlow;
             }
 
-            int HotConNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWControlNode;
+            int HotConNode = indUnit.HWControlNode;
             if (HotConNode > 0 && !state.dataHVACSingleDuctInduc->MyPlantScanFlag(IUNum)) {
 
-                rho = state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum)
+                rho = state.dataPlnt->PlantLoop(indUnit.HWPlantLoc.loopNum)
                           .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxHotWaterFlow =
-                    rho * state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow;
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinHotWaterFlow =
-                    rho * state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinVolHotWaterFlow;
+                indUnit.MaxHotWaterFlow =
+                    rho * indUnit.MaxVolHotWaterFlow;
+                indUnit.MinHotWaterFlow =
+                    rho * indUnit.MinVolHotWaterFlow;
                 // get component outlet node from plant structure
-                int HWOutletNode = DataPlant::CompData::getPlantComponent(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc).NodeNumOut;
+                int HWOutletNode = DataPlant::CompData::getPlantComponent(state, indUnit.HWPlantLoc).NodeNumOut;
                 PlantUtilities::InitComponentNodes(state,
-                                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinHotWaterFlow,
-                                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxHotWaterFlow,
+                                                   indUnit.MinHotWaterFlow,
+                                                   indUnit.MaxHotWaterFlow,
                                                    HotConNode,
                                                    HWOutletNode);
             }
 
-            int ColdConNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWControlNode;
+            int ColdConNode = indUnit.CWControlNode;
             if (ColdConNode > 0) {
-                rho = state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum)
+                rho = state.dataPlnt->PlantLoop(indUnit.CWPlantLoc.loopNum)
                           .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName);
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxColdWaterFlow =
-                    rho * state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow;
-                state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinColdWaterFlow =
-                    rho * state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinVolColdWaterFlow;
+                indUnit.MaxColdWaterFlow =
+                    rho * indUnit.MaxVolColdWaterFlow;
+                indUnit.MinColdWaterFlow =
+                    rho * indUnit.MinVolColdWaterFlow;
 
-                int CWOutletNode = DataPlant::CompData::getPlantComponent(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc).NodeNumOut;
+                int CWOutletNode = DataPlant::CompData::getPlantComponent(state, indUnit.CWPlantLoc).NodeNumOut;
                 PlantUtilities::InitComponentNodes(state,
-                                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinColdWaterFlow,
-                                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxColdWaterFlow,
+                                                   indUnit.MinColdWaterFlow,
+                                                   indUnit.MaxColdWaterFlow,
                                                    ColdConNode,
                                                    CWOutletNode);
             }
@@ -652,32 +657,32 @@ namespace HVACSingleDuctInduc {
             state.dataHVACSingleDuctInduc->MyEnvrnFlag(IUNum) = true;
         }
 
-        PriNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).PriAirInNode;
-        SecNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).SecAirInNode;
+        PriNode = indUnit.PriAirInNode;
+        SecNode = indUnit.SecAirInNode;
 
         // Do the start of HVAC time step initializations
         if (FirstHVACIteration) {
             // check for upstream zero flow. If nonzero and schedule ON, set primary flow to max
-            if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).availSched->getCurrentVal() > 0.0 &&
+            if (indUnit.availSched->getCurrentVal() > 0.0 &&
                 state.dataLoopNodes->Node(PriNode).MassFlowRate > 0.0) {
-                if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
+                if (Util::SameString(indUnit.UnitType,
                                      "AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction")) {
-                    state.dataLoopNodes->Node(PriNode).MassFlowRate = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxPriAirMassFlow;
-                    state.dataLoopNodes->Node(SecNode).MassFlowRate = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxSecAirMassFlow;
+                    state.dataLoopNodes->Node(PriNode).MassFlowRate = indUnit.MaxPriAirMassFlow;
+                    state.dataLoopNodes->Node(SecNode).MassFlowRate = indUnit.MaxSecAirMassFlow;
                 }
             } else {
                 state.dataLoopNodes->Node(PriNode).MassFlowRate = 0.0;
                 state.dataLoopNodes->Node(SecNode).MassFlowRate = 0.0;
             }
             // reset the max and min avail flows
-            if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).availSched->getCurrentVal() > 0.0 &&
+            if (indUnit.availSched->getCurrentVal() > 0.0 &&
                 state.dataLoopNodes->Node(PriNode).MassFlowRateMaxAvail > 0.0) {
-                if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
+                if (Util::SameString(indUnit.UnitType,
                                      "AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction")) {
-                    state.dataLoopNodes->Node(PriNode).MassFlowRateMaxAvail = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxPriAirMassFlow;
-                    state.dataLoopNodes->Node(PriNode).MassFlowRateMinAvail = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxPriAirMassFlow;
-                    state.dataLoopNodes->Node(SecNode).MassFlowRateMaxAvail = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxSecAirMassFlow;
-                    state.dataLoopNodes->Node(SecNode).MassFlowRateMinAvail = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxSecAirMassFlow;
+                    state.dataLoopNodes->Node(PriNode).MassFlowRateMaxAvail = indUnit.MaxPriAirMassFlow;
+                    state.dataLoopNodes->Node(PriNode).MassFlowRateMinAvail = indUnit.MaxPriAirMassFlow;
+                    state.dataLoopNodes->Node(SecNode).MassFlowRateMaxAvail = indUnit.MaxSecAirMassFlow;
+                    state.dataLoopNodes->Node(SecNode).MassFlowRateMinAvail = indUnit.MaxSecAirMassFlow;
                 }
             } else {
                 state.dataLoopNodes->Node(PriNode).MassFlowRateMaxAvail = 0.0;
@@ -724,21 +729,23 @@ namespace HVACSingleDuctInduc {
         Real64 MaxVolColdWaterFlowDes = 0.0;  // Design size maximum cold water flow for reporting
         Real64 MaxVolColdWaterFlowUser = 0.0; // User hard-sized maximum cold water flow for reporting
 
-        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow == DataSizing::AutoSize) {
+        auto &indUnit = state.dataHVACSingleDuctInduc->IndUnit(IUNum);
+        
+        if (indUnit.MaxTotAirVolFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
 
         if (state.dataSize->CurZoneEqNum > 0) {
             if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // simulation continue
-                if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow > 0.0) {
+                if (indUnit.MaxTotAirVolFlow > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                 indUnit.UnitType,
+                                                 indUnit.Name,
                                                  "User-Specified Maximum Total Air Flow Rate [m3/s]",
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow);
+                                                 indUnit.MaxTotAirVolFlow);
                 }
             } else {
-                CheckZoneSizing(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name);
+                CheckZoneSizing(state, indUnit.UnitType, indUnit.Name);
                 if (state.dataSize->CurTermUnitSizingNum > 0) {
                     MaxTotAirVolFlowDes = max(state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesCoolVolFlow,
                                               state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatVolFlow);
@@ -749,18 +756,18 @@ namespace HVACSingleDuctInduc {
                     MaxTotAirVolFlowDes = 0.0;
                 }
                 if (IsAutoSize) {
-                    state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow = MaxTotAirVolFlowDes;
+                    indUnit.MaxTotAirVolFlow = MaxTotAirVolFlowDes;
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                 indUnit.UnitType,
+                                                 indUnit.Name,
                                                  "Design Size Maximum Total Air Flow Rate [m3/s]",
                                                  MaxTotAirVolFlowDes);
                 } else {
-                    if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow > 0.0 && MaxTotAirVolFlowDes > 0.0) {
-                        MaxTotAirVolFlowUser = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow;
+                    if (indUnit.MaxTotAirVolFlow > 0.0 && MaxTotAirVolFlowDes > 0.0) {
+                        MaxTotAirVolFlowUser = indUnit.MaxTotAirVolFlow;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                     indUnit.UnitType,
+                                                     indUnit.Name,
                                                      "Design Size Maximum Total Air Flow Rate [m3/s]",
                                                      MaxTotAirVolFlowDes,
                                                      "User-Specified Maximum Total Air Flow Rate [m3/s]",
@@ -770,8 +777,8 @@ namespace HVACSingleDuctInduc {
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state,
                                             format("SizeHVACSingleDuctInduction: Potential issue with equipment sizing for {} = \"{}\".",
-                                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                   indUnit.UnitType,
+                                                   indUnit.Name));
                                 ShowContinueError(state, format("User-Specified Maximum Total Air Flow Rate of {:.5R} [m3/s]", MaxTotAirVolFlowUser));
                                 ShowContinueError(
                                     state, format("differs from Design Size Maximum Total Air Flow Rate of {:.5R} [m3/s]", MaxTotAirVolFlowDes));
@@ -785,31 +792,29 @@ namespace HVACSingleDuctInduc {
         }
 
         IsAutoSize = false;
-        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow == DataSizing::AutoSize) {
+        if (indUnit.MaxVolHotWaterFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
         if ((state.dataSize->CurZoneEqNum > 0) && (state.dataSize->CurTermUnitSizingNum > 0)) {
             if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // simulation continue
-                if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow > 0.0) {
+                if (indUnit.MaxVolHotWaterFlow > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                 indUnit.UnitType,
+                                                 indUnit.Name,
                                                  "User-Specified Maximum Hot Water Flow Rate [m3/s]",
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow);
+                                                 indUnit.MaxVolHotWaterFlow);
                 }
             } else {
-                CheckZoneSizing(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name);
+                CheckZoneSizing(state, indUnit.UnitType, indUnit.Name);
 
-                if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoilType, "Coil:Heating:Water")) {
+                if (indUnit.heatCoilType == HVAC::CoilType::HeatingWater) {
 
-                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(
-                        state, "Coil:Heating:Water", state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil, ErrorsFound);
-                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(
-                        state, "Coil:Heating:Water", state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil, ErrorsFound);
+                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, indUnit.heatCoilNum);
+                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, indUnit.heatCoilNum);
                     if (IsAutoSize) {
                         int PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(state,
                                                                                "Coil:Heating:Water",
-                                                                               state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil,
+                                                                               indUnit.heatCoilName,
                                                                                CoilWaterInletNode,
                                                                                CoilWaterOutletNode,
                                                                                ErrorsFound);
@@ -817,8 +822,7 @@ namespace HVACSingleDuctInduc {
 
                             if (state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatMassFlow >=
                                 HVAC::SmallAirVolFlow) {
-                                DesPriVolFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow /
-                                                (1.0 + state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio);
+                                DesPriVolFlow = indUnit.MaxTotAirVolFlow / (1.0 + indUnit.InducRatio);
                                 CpAir = Psychrometrics::PsyCpAirFnW(
                                     state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).HeatDesHumRat);
                                 // the design heating coil load is the zone load minus whatever the central system does. Note that
@@ -834,11 +838,11 @@ namespace HVACSingleDuctInduc {
                                                   (state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneSizThermSetPtLo -
                                                    state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU);
                                 }
-                                state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesHeatingLoad = DesCoilLoad;
-                                Cp = state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum)
+                                indUnit.DesHeatingLoad = DesCoilLoad;
+                                Cp = state.dataPlnt->PlantLoop(indUnit.HWPlantLoc.loopNum)
                                          .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName);
 
-                                rho = state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc.loopNum)
+                                rho = state.dataPlnt->PlantLoop(indUnit.HWPlantLoc.loopNum)
                                           .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
 
                                 MaxVolHotWaterFlowDes = DesCoilLoad / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho);
@@ -850,34 +854,34 @@ namespace HVACSingleDuctInduc {
                             ShowSevereError(state, "Autosizing of water flow requires a heating loop Sizing:Plant object");
                             ShowContinueError(state,
                                               format("Occurs in{} Object={}",
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                     indUnit.UnitType,
+                                                     indUnit.Name));
                             ErrorsFound = true;
                         }
-                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow = MaxVolHotWaterFlowDes;
+                        indUnit.MaxVolHotWaterFlow = MaxVolHotWaterFlowDes;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                     indUnit.UnitType,
+                                                     indUnit.Name,
                                                      "Design Size Maximum Hot Water Flow Rate [m3/s]",
                                                      MaxVolHotWaterFlowDes);
                         BaseSizer::reportSizerOutput(
                             state,
-                            state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                            state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                            indUnit.UnitType,
+                            indUnit.Name,
                             "Design Size Inlet Air Temperature [C]",
                             state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU);
                         BaseSizer::reportSizerOutput(
                             state,
-                            state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                            state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                            indUnit.UnitType,
+                            indUnit.Name,
                             "Design Size Inlet Air Humidity Ratio [kgWater/kgDryAir]",
                             state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInHumRatTU);
                     } else {
-                        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow > 0.0 && MaxVolHotWaterFlowDes > 0.0) {
-                            MaxVolHotWaterFlowUser = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow;
+                        if (indUnit.MaxVolHotWaterFlow > 0.0 && MaxVolHotWaterFlowDes > 0.0) {
+                            MaxVolHotWaterFlowUser = indUnit.MaxVolHotWaterFlow;
                             BaseSizer::reportSizerOutput(state,
-                                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                         indUnit.UnitType,
+                                                         indUnit.Name,
                                                          "Design Size Maximum Hot Water Flow Rate [m3/s]",
                                                          MaxVolHotWaterFlowDes,
                                                          "User-Specified Maximum Hot Water Flow Rate [m3/s]",
@@ -887,8 +891,8 @@ namespace HVACSingleDuctInduc {
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
                                                 format("SizeHVACSingleDuctInduction: Potential issue with equipment sizing for {} = \"{}\".",
-                                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                       indUnit.UnitType,
+                                                       indUnit.Name));
                                     ShowContinueError(state,
                                                       format("User-Specified Maximum Hot Water Flow Rate of {:.5R} [m3/s]", MaxVolHotWaterFlowUser));
                                     ShowContinueError(
@@ -901,42 +905,36 @@ namespace HVACSingleDuctInduc {
                         }
                     }
                 } else {
-                    state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow = 0.0;
+                    indUnit.MaxVolHotWaterFlow = 0.0;
                 }
             }
         }
 
         IsAutoSize = false;
-        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow == DataSizing::AutoSize) {
+        if (indUnit.MaxVolColdWaterFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
         if ((state.dataSize->CurZoneEqNum > 0) && (state.dataSize->CurTermUnitSizingNum > 0)) {
             if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // simulation continue
-                if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow > 0.0) {
+                if (indUnit.MaxVolColdWaterFlow > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                 indUnit.UnitType,
+                                                 indUnit.Name,
                                                  "User-Specified Maximum Cold Water Flow Rate [m3/s]",
-                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow);
+                                                 indUnit.MaxVolColdWaterFlow);
                 }
             } else {
-                CheckZoneSizing(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name);
+                CheckZoneSizing(state, indUnit.UnitType, indUnit.Name);
 
-                if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType, "Coil:Cooling:Water") ||
-                    Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType, "Coil:Cooling:Water:DetailedGeometry")) {
+                if (indUnit.coolCoilType == HVAC::CoilType::CoolingWater ||
+                    indUnit.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
 
-                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state,
-                                                                               state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType,
-                                                                               state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil,
-                                                                               ErrorsFound);
-                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state,
-                                                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType,
-                                                                                 state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil,
-                                                                                 ErrorsFound);
+                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, indUnit.coolCoilNum);
+                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, indUnit.coolCoilNum);
                     if (IsAutoSize) {
                         int PltSizCoolNum = PlantUtilities::MyPlantSizingIndex(state,
-                                                                               state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType,
-                                                                               state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil,
+                                                                               HVAC::coilTypeNames[(int)indUnit.coolCoilType],
+                                                                               indUnit.coolCoilName,
                                                                                CoilWaterInletNode,
                                                                                CoilWaterOutletNode,
                                                                                ErrorsFound);
@@ -944,8 +942,7 @@ namespace HVACSingleDuctInduc {
 
                             if (state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesCoolMassFlow >=
                                 HVAC::SmallAirVolFlow) {
-                                DesPriVolFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow /
-                                                (1.0 + state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio);
+                                DesPriVolFlow = indUnit.MaxTotAirVolFlow / (1.0 + indUnit.InducRatio);
                                 CpAir = Psychrometrics::PsyCpAirFnW(
                                     state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).CoolDesHumRat);
                                 // the design cooling coil load is the zone load minus whatever the central system does. Note that
@@ -961,11 +958,11 @@ namespace HVACSingleDuctInduc {
                                                   (state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesCoolCoilInTempTU -
                                                    state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneSizThermSetPtHi);
                                 }
-                                state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesCoolingLoad = DesCoilLoad;
-                                Cp = state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum)
+                                indUnit.DesCoolingLoad = DesCoilLoad;
+                                Cp = state.dataPlnt->PlantLoop(indUnit.CWPlantLoc.loopNum)
                                          .glycol->getSpecificHeat(state, 5.0, RoutineName);
 
-                                rho = state.dataPlnt->PlantLoop(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc.loopNum)
+                                rho = state.dataPlnt->PlantLoop(indUnit.CWPlantLoc.loopNum)
                                           .glycol->getDensity(state, 5.0, RoutineName);
 
                                 MaxVolColdWaterFlowDes = DesCoilLoad / (state.dataSize->PlantSizData(PltSizCoolNum).DeltaT * Cp * rho);
@@ -977,22 +974,22 @@ namespace HVACSingleDuctInduc {
                             ShowSevereError(state, "Autosizing of water flow requires a cooling loop Sizing:Plant object");
                             ShowContinueError(state,
                                               format("Occurs in{} Object={}",
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                     indUnit.UnitType,
+                                                     indUnit.Name));
                             ErrorsFound = true;
                         }
-                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow = MaxVolColdWaterFlowDes;
+                        indUnit.MaxVolColdWaterFlow = MaxVolColdWaterFlowDes;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                     state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                     indUnit.UnitType,
+                                                     indUnit.Name,
                                                      "Design Size Maximum Cold Water Flow Rate [m3/s]",
                                                      MaxVolColdWaterFlowDes);
                     } else {
-                        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow > 0.0 && MaxVolColdWaterFlowDes > 0.0) {
-                            MaxVolColdWaterFlowUser = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow;
+                        if (indUnit.MaxVolColdWaterFlow > 0.0 && MaxVolColdWaterFlowDes > 0.0) {
+                            MaxVolColdWaterFlowUser = indUnit.MaxVolColdWaterFlow;
                             BaseSizer::reportSizerOutput(state,
-                                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                         state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name,
+                                                         indUnit.UnitType,
+                                                         indUnit.Name,
                                                          "Design Size Maximum Cold Water Flow Rate [m3/s]",
                                                          MaxVolColdWaterFlowDes,
                                                          "User-Specified Maximum Cold Water Flow Rate [m3/s]",
@@ -1002,8 +999,8 @@ namespace HVACSingleDuctInduc {
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
                                                 format("SizeHVACSingleDuctInduction: Potential issue with equipment sizing for {} = \"{}\".",
-                                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                       indUnit.UnitType,
+                                                       indUnit.Name));
                                     ShowContinueError(
                                         state, format("User-Specified Maximum Cold Water Flow Rate of {:.5R} [m3/s]", MaxVolColdWaterFlowUser));
                                     ShowContinueError(
@@ -1016,7 +1013,7 @@ namespace HVACSingleDuctInduc {
                         }
                     }
                 } else {
-                    state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow = 0.0;
+                    indUnit.MaxVolColdWaterFlow = 0.0;
                 }
             }
         }
@@ -1025,30 +1022,23 @@ namespace HVACSingleDuctInduc {
             auto &termUnitSizing = state.dataSize->TermUnitSizing(state.dataSize->CurTermUnitSizingNum);
 
             // note we save the induced air flow for use by the hw and cw coil sizing routines
-            termUnitSizing.AirVolFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirVolFlow *
-                                        state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio /
-                                        (1.0 + state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio);
+            termUnitSizing.AirVolFlow = indUnit.MaxTotAirVolFlow *
+                                        indUnit.InducRatio /
+                                        (1.0 + indUnit.InducRatio);
             // save the max hot and cold water flows for use in coil sizing
-            termUnitSizing.MaxHWVolFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolHotWaterFlow;
-            termUnitSizing.MaxCWVolFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxVolColdWaterFlow;
+            termUnitSizing.MaxHWVolFlow = indUnit.MaxVolHotWaterFlow;
+            termUnitSizing.MaxCWVolFlow = indUnit.MaxVolColdWaterFlow;
             // save the design load used for reporting
-            termUnitSizing.DesCoolingLoad = state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesCoolingLoad;
-            termUnitSizing.DesHeatingLoad = state.dataHVACSingleDuctInduc->IndUnit(IUNum).DesHeatingLoad;
+            termUnitSizing.DesCoolingLoad = indUnit.DesCoolingLoad;
+            termUnitSizing.DesHeatingLoad = indUnit.DesHeatingLoad;
             // save the induction ratio for use in subsequent sizing calcs
-            termUnitSizing.InducRat = state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio;
-            if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoilType, "Coil:Heating:Water")) {
-                WaterCoils::SetCoilDesFlow(state,
-                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoilType,
-                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil,
-                                           termUnitSizing.AirVolFlow,
-                                           ErrorsFound);
+            termUnitSizing.InducRat = indUnit.InducRatio;
+            if (indUnit.heatCoilType == HVAC::CoilType::HeatingWater) {
+                WaterCoils::SetCoilDesFlow(state, indUnit.heatCoilNum, termUnitSizing.AirVolFlow);
             }
-            if (Util::SameString(state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType, "Coil:Cooling:Water:DetailedGeometry")) {
-                WaterCoils::SetCoilDesFlow(state,
-                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoilType,
-                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil,
-                                           termUnitSizing.AirVolFlow,
-                                           ErrorsFound);
+            if (indUnit.coolCoilType == HVAC::CoilType::CoolingWater ||
+                indUnit.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
+                WaterCoils::SetCoilDesFlow(state, indUnit.coolCoilNum, termUnitSizing.AirVolFlow);
             }
         }
     }
@@ -1086,16 +1076,18 @@ namespace HVACSingleDuctInduc {
         Real64 QPriOnly; // unit output with no zone coils active
         Real64 ErrTolerance;
 
+        auto &indUnit = state.dataHVACSingleDuctInduc->IndUnit(IUNum);
+        
         bool UnitOn = true;
         Real64 PowerMet = 0.0;
-        Real64 InducRat = state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio;
-        int PriNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).PriAirInNode;
-        int SecNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).SecAirInNode;
-        int OutletNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode;
-        int HotControlNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWControlNode;
-        int HWOutletNode = DataPlant::CompData::getPlantComponent(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc).NodeNumOut;
-        int ColdControlNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWControlNode;
-        int CWOutletNode = DataPlant::CompData::getPlantComponent(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc).NodeNumOut;
+        Real64 InducRat = indUnit.InducRatio;
+        int PriNode = indUnit.PriAirInNode;
+        int SecNode = indUnit.SecAirInNode;
+        int OutletNode = indUnit.OutAirNode;
+        int HotControlNode = indUnit.HWControlNode;
+        int HWOutletNode = DataPlant::CompData::getPlantComponent(state, indUnit.HWPlantLoc).NodeNumOut;
+        int ColdControlNode = indUnit.CWControlNode;
+        int CWOutletNode = DataPlant::CompData::getPlantComponent(state, indUnit.CWPlantLoc).NodeNumOut;
         Real64 PriAirMassFlow = state.dataLoopNodes->Node(PriNode).MassFlowRateMaxAvail;
         Real64 SecAirMassFlow = InducRat * PriAirMassFlow;
         Real64 QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputReqToHeatSP;
@@ -1103,23 +1095,23 @@ namespace HVACSingleDuctInduc {
         // On the first HVAC iteration the system values are given to the controller, but after that
         // the demand limits are in place and there needs to be feedback to the Zone Equipment
 
-        Real64 MaxHotWaterFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxHotWaterFlow;
+        Real64 MaxHotWaterFlow = indUnit.MaxHotWaterFlow;
         PlantUtilities::SetComponentFlowRate(
-            state, MaxHotWaterFlow, HotControlNode, HWOutletNode, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc);
+            state, MaxHotWaterFlow, HotControlNode, HWOutletNode, indUnit.HWPlantLoc);
 
-        Real64 MinHotWaterFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinHotWaterFlow;
+        Real64 MinHotWaterFlow = indUnit.MinHotWaterFlow;
         PlantUtilities::SetComponentFlowRate(
-            state, MinHotWaterFlow, HotControlNode, HWOutletNode, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc);
+            state, MinHotWaterFlow, HotControlNode, HWOutletNode, indUnit.HWPlantLoc);
 
-        Real64 MaxColdWaterFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxColdWaterFlow;
+        Real64 MaxColdWaterFlow = indUnit.MaxColdWaterFlow;
         PlantUtilities::SetComponentFlowRate(
-            state, MaxColdWaterFlow, ColdControlNode, CWOutletNode, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc);
+            state, MaxColdWaterFlow, ColdControlNode, CWOutletNode, indUnit.CWPlantLoc);
 
-        Real64 MinColdWaterFlow = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MinColdWaterFlow;
+        Real64 MinColdWaterFlow = indUnit.MinColdWaterFlow;
         PlantUtilities::SetComponentFlowRate(
-            state, MinColdWaterFlow, ColdControlNode, CWOutletNode, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc);
+            state, MinColdWaterFlow, ColdControlNode, CWOutletNode, indUnit.CWPlantLoc);
 
-        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).availSched->getCurrentVal() <= 0.0) UnitOn = false;
+        if (indUnit.availSched->getCurrentVal() <= 0.0) UnitOn = false;
         if (PriAirMassFlow <= HVAC::SmallMassFlow) UnitOn = false;
 
         // Set the unit's air inlet nodes mass flow rates
@@ -1138,7 +1130,7 @@ namespace HVACSingleDuctInduc {
                 // check that it can meet the load
                 CalcFourPipeIndUnit(state, IUNum, FirstHVACIteration, ZoneNodeNum, MaxHotWaterFlow, MinColdWaterFlow, PowerMet);
                 if (PowerMet > QToHeatSetPt + HVAC::SmallLoad) {
-                    ErrTolerance = state.dataHVACSingleDuctInduc->IndUnit(IUNum).HotControlOffset;
+                    ErrTolerance = indUnit.HotControlOffset;
                     auto f = // (AUTO_OK_LAMBDA)
                         [&state, IUNum, FirstHVACIteration, ZoneNodeNum, MinColdWaterFlow, QToHeatSetPt, QPriOnly, PowerMet](Real64 const HWFlow) {
                             Real64 UnitOutput;
@@ -1147,11 +1139,11 @@ namespace HVACSingleDuctInduc {
                         };
                     General::SolveRoot(state, ErrTolerance, SolveMaxIter, SolFlag, HWFlow, f, MinHotWaterFlow, MaxHotWaterFlow);
                     if (SolFlag == -1) {
-                        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWCoilFailNum1 == 0) {
+                        if (indUnit.HWCoilFailNum1 == 0) {
                             ShowWarningMessage(state,
                                                format("SimFourPipeIndUnit: Hot water coil control failed for {}=\"{}\"",
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                      indUnit.UnitType,
+                                                      indUnit.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, format("  Iteration limit [{}] exceeded in calculating hot water mass flow rate", SolveMaxIter));
                         }
@@ -1159,15 +1151,15 @@ namespace HVACSingleDuctInduc {
                             state,
                             format("SimFourPipeIndUnit: Hot water coil control failed (iteration limit [{}]) for {}=\"{}\"",
                                    SolveMaxIter,
-                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                   state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name),
-                            state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWCoilFailNum1);
+                                   indUnit.UnitType,
+                                   indUnit.Name),
+                            indUnit.HWCoilFailNum1);
                     } else if (SolFlag == -2) {
-                        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWCoilFailNum2 == 0) {
+                        if (indUnit.HWCoilFailNum2 == 0) {
                             ShowWarningMessage(state,
                                                format("SimFourPipeIndUnit: Hot water coil control failed (maximum flow limits) for {}=\"{}\"",
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                      indUnit.UnitType,
+                                                      indUnit.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, "...Bad hot water maximum flow rate limits");
                             ShowContinueError(state, format("...Given minimum water flow rate={:.3R} kg/s", MinHotWaterFlow));
@@ -1175,9 +1167,9 @@ namespace HVACSingleDuctInduc {
                         }
                         ShowRecurringWarningErrorAtEnd(state,
                                                        "SimFourPipeIndUnit: Hot water coil control failed (flow limits) for " +
-                                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType + "=\"" +
-                                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name + "\"",
-                                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWCoilFailNum2,
+                                                           indUnit.UnitType + "=\"" +
+                                                           indUnit.Name + "\"",
+                                                       indUnit.HWCoilFailNum2,
                                                        MaxHotWaterFlow,
                                                        MinHotWaterFlow,
                                                        _,
@@ -1190,7 +1182,7 @@ namespace HVACSingleDuctInduc {
                 // check that it can meet the load
                 CalcFourPipeIndUnit(state, IUNum, FirstHVACIteration, ZoneNodeNum, MinHotWaterFlow, MaxColdWaterFlow, PowerMet);
                 if (PowerMet < QToCoolSetPt - HVAC::SmallLoad) {
-                    ErrTolerance = state.dataHVACSingleDuctInduc->IndUnit(IUNum).ColdControlOffset;
+                    ErrTolerance = indUnit.ColdControlOffset;
                     auto f = // (AUTO_OK_LAMBDA)
                         [&state, IUNum, FirstHVACIteration, ZoneNodeNum, MinHotWaterFlow, QToCoolSetPt, QPriOnly, PowerMet](Real64 const CWFlow) {
                             Real64 UnitOutput;
@@ -1199,11 +1191,11 @@ namespace HVACSingleDuctInduc {
                         };
                     General::SolveRoot(state, ErrTolerance, SolveMaxIter, SolFlag, CWFlow, f, MinColdWaterFlow, MaxColdWaterFlow);
                     if (SolFlag == -1) {
-                        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWCoilFailNum1 == 0) {
+                        if (indUnit.CWCoilFailNum1 == 0) {
                             ShowWarningMessage(state,
                                                format("SimFourPipeIndUnit: Cold water coil control failed for {}=\"{}\"",
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                      indUnit.UnitType,
+                                                      indUnit.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state,
                                               format("  Iteration limit [{}] exceeded in calculating cold water mass flow rate", SolveMaxIter));
@@ -1211,15 +1203,15 @@ namespace HVACSingleDuctInduc {
                         ShowRecurringWarningErrorAtEnd(state,
                                                        format("SimFourPipeIndUnit: Cold water coil control failed (iteration limit [{}]) for {}=\"{}",
                                                               SolveMaxIter,
-                                                              state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                              state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name),
-                                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWCoilFailNum1);
+                                                              indUnit.UnitType,
+                                                              indUnit.Name),
+                                                       indUnit.CWCoilFailNum1);
                     } else if (SolFlag == -2) {
-                        if (state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWCoilFailNum2 == 0) {
+                        if (indUnit.CWCoilFailNum2 == 0) {
                             ShowWarningMessage(state,
                                                format("SimFourPipeIndUnit: Cold water coil control failed (maximum flow limits) for {}=\"{}\"",
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType,
-                                                      state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name));
+                                                      indUnit.UnitType,
+                                                      indUnit.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, "...Bad cold water maximum flow rate limits");
                             ShowContinueError(state, format("...Given minimum water flow rate={:.3R} kg/s", MinColdWaterFlow));
@@ -1227,9 +1219,9 @@ namespace HVACSingleDuctInduc {
                         }
                         ShowRecurringWarningErrorAtEnd(state,
                                                        "SimFourPipeIndUnit: Cold water coil control failed (flow limits) for " +
-                                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).UnitType + "=\"" +
-                                                           state.dataHVACSingleDuctInduc->IndUnit(IUNum).Name + "\"",
-                                                       state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWCoilFailNum2,
+                                                           indUnit.UnitType + "=\"" +
+                                                           indUnit.Name + "\"",
+                                                       indUnit.CWCoilFailNum2,
                                                        MaxColdWaterFlow,
                                                        MinColdWaterFlow,
                                                        _,
@@ -1245,7 +1237,7 @@ namespace HVACSingleDuctInduc {
             // unit off
             CalcFourPipeIndUnit(state, IUNum, FirstHVACIteration, ZoneNodeNum, MinHotWaterFlow, MinColdWaterFlow, PowerMet);
         }
-        state.dataLoopNodes->Node(OutletNode).MassFlowRateMax = state.dataHVACSingleDuctInduc->IndUnit(IUNum).MaxTotAirMassFlow;
+        state.dataLoopNodes->Node(OutletNode).MassFlowRateMax = indUnit.MaxTotAirMassFlow;
 
         // At this point we are done. There is no output to report or pass back up: the output provided is calculated
         // one level up in the calling routine SimZoneAirLoopEquipment. All the inlet and outlet flow rates and
@@ -1286,33 +1278,31 @@ namespace HVACSingleDuctInduc {
         int HWOutletNode;
         int CWOutletNode;
 
-        PriNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).PriAirInNode;
-        OutletNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).OutAirNode;
+        auto &indUnit = state.dataHVACSingleDuctInduc->IndUnit(IUNum);
+        PriNode = indUnit.PriAirInNode;
+        OutletNode = indUnit.OutAirNode;
         PriAirMassFlow = state.dataLoopNodes->Node(PriNode).MassFlowRateMaxAvail;
-        InducRat = state.dataHVACSingleDuctInduc->IndUnit(IUNum).InducRatio;
+        InducRat = indUnit.InducRatio;
         SecAirMassFlow = InducRat * PriAirMassFlow;
         TotAirMassFlow = PriAirMassFlow + SecAirMassFlow;
-        HotControlNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWControlNode;
-        HWOutletNode = DataPlant::CompData::getPlantComponent(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc).NodeNumOut;
+        HotControlNode = indUnit.HWControlNode;
+        HWOutletNode = DataPlant::CompData::getPlantComponent(state, indUnit.HWPlantLoc).NodeNumOut;
 
-        ColdControlNode = state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWControlNode;
-        CWOutletNode = DataPlant::CompData::getPlantComponent(state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc).NodeNumOut;
+        ColdControlNode = indUnit.CWControlNode;
+        CWOutletNode = DataPlant::CompData::getPlantComponent(state, indUnit.CWPlantLoc).NodeNumOut;
 
         mdotHW = HWFlow;
-        PlantUtilities::SetComponentFlowRate(state, mdotHW, HotControlNode, HWOutletNode, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HWPlantLoc);
+        PlantUtilities::SetComponentFlowRate(state, mdotHW, HotControlNode, HWOutletNode, indUnit.HWPlantLoc);
 
         //  Node(HotControlNode)%MassFlowRate = HWFlow
 
         mdotCW = CWFlow;
-        PlantUtilities::SetComponentFlowRate(state, mdotCW, ColdControlNode, CWOutletNode, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CWPlantLoc);
+        PlantUtilities::SetComponentFlowRate(state, mdotCW, ColdControlNode, CWOutletNode, indUnit.CWPlantLoc);
         //  Node(ColdControlNode)%MassFlowRate = CWFlow
 
-        WaterCoils::SimulateWaterCoilComponents(
-            state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil, FirstHVACIteration, state.dataHVACSingleDuctInduc->IndUnit(IUNum).HCoil_Num);
-        WaterCoils::SimulateWaterCoilComponents(
-            state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil, FirstHVACIteration, state.dataHVACSingleDuctInduc->IndUnit(IUNum).CCoil_Num);
-        MixerComponent::SimAirMixer(
-            state, state.dataHVACSingleDuctInduc->IndUnit(IUNum).MixerName, state.dataHVACSingleDuctInduc->IndUnit(IUNum).Mixer_Num);
+        WaterCoils::SimulateWaterCoilComponents(state, indUnit.heatCoilNum, FirstHVACIteration);
+        WaterCoils::SimulateWaterCoilComponents(state, indUnit.coolCoilNum, FirstHVACIteration);
+        MixerComponent::SimAirMixer(state, indUnit.MixerName, indUnit.Mixer_Num);
         LoadMet = TotAirMassFlow * Psychrometrics::PsyDeltaHSenFnTdb2W2Tdb1W1(state.dataLoopNodes->Node(OutletNode).Temp,
                                                                               state.dataLoopNodes->Node(OutletNode).HumRat,
                                                                               state.dataLoopNodes->Node(ZoneNode).Temp,
@@ -1379,8 +1369,8 @@ namespace HVACSingleDuctInduc {
         OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a");
         OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "n/a");
         OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a");
-        OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, this->HCoilType);
-        OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, this->CCoilType);
+        OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, HVAC::coilTypeNames[(int)this->heatCoilType]);
+        OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, HVAC::coilTypeNames[(int)this->coolCoilType]);
         OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, "n/a");
         OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, "n/a");
     }
diff --git a/src/EnergyPlus/HVACSingleDuctInduc.hh b/src/EnergyPlus/HVACSingleDuctInduc.hh
index 544922d5f2e..fc8ca4e6ccc 100644
--- a/src/EnergyPlus/HVACSingleDuctInduc.hh
+++ b/src/EnergyPlus/HVACSingleDuctInduc.hh
@@ -88,10 +88,11 @@ namespace HVACSingleDuctInduc {
         int OutAirNode;                        // unit air outlet node number
         int HWControlNode;                     // hot water control node
         int CWControlNode;                     // cold water control node
-        std::string HCoilType;                 // type of heating coil component
-        std::string HCoil;                     // name of heating coil component
-        int HCoil_Num;                         // index to this coil
-        DataPlant::PlantEquipmentType HeatingCoilType;
+
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;                 // type of heating coil component
+        std::string heatCoilName;                     // name of heating coil component
+        int heatCoilNum = 0;                         // index to this coil
+        DataPlant::PlantEquipmentType heatCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
         Real64 MaxVolHotWaterFlow; // m3/s (autosizable)
         Real64 MaxHotWaterFlow;    // kg/s
         Real64 MinVolHotWaterFlow; // m3/s
@@ -100,10 +101,12 @@ namespace HVACSingleDuctInduc {
         PlantLocation HWPlantLoc;  // index for plant location for hot water coil
         int HWCoilFailNum1;        // index for errors
         int HWCoilFailNum2;        // index for errors
-        std::string CCoilType;     // type of cooling coil component
-        std::string CCoil;         // name of cooling coil component
-        int CCoil_Num;             // index to this coil
-        DataPlant::PlantEquipmentType CoolingCoilType;
+
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;     // type of cooling coil component
+        std::string coolCoilName;         // name of cooling coil component
+        int coolCoilNum = 0;             // index to this coil
+        DataPlant::PlantEquipmentType coolCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+
         Real64 MaxVolColdWaterFlow; // m3/s (autosizable)
         Real64 MaxColdWaterFlow;    // kg/s
         Real64 MinVolColdWaterFlow; // m3/s
@@ -127,9 +130,9 @@ namespace HVACSingleDuctInduc {
         // Default Constructor
         IndUnitData()
             : UnitType_Num(SingleDuct_CV::Invalid), MaxTotAirVolFlow(0.0), MaxTotAirMassFlow(0.0), InducRatio(2.5), PriAirInNode(0), SecAirInNode(0),
-              OutAirNode(0), HWControlNode(0), CWControlNode(0), HCoil_Num(0), HeatingCoilType(DataPlant::PlantEquipmentType::Invalid),
+              OutAirNode(0), HWControlNode(0), CWControlNode(0), 
               MaxVolHotWaterFlow(0.0), MaxHotWaterFlow(0.0), MinVolHotWaterFlow(0.0), MinHotWaterFlow(0.0), HotControlOffset(0.0), HWPlantLoc{},
-              HWCoilFailNum1(0), HWCoilFailNum2(0), CCoil_Num(0), CoolingCoilType(DataPlant::PlantEquipmentType::Invalid), MaxVolColdWaterFlow(0.0),
+              HWCoilFailNum1(0), HWCoilFailNum2(0), MaxVolColdWaterFlow(0.0),
               MaxColdWaterFlow(0.0), MinVolColdWaterFlow(0.0), MinColdWaterFlow(0.0), ColdControlOffset(0.0), CWPlantLoc{}, CWCoilFailNum1(0),
               CWCoilFailNum2(0), Mixer_Num(0), MaxPriAirMassFlow(0.0), MaxSecAirMassFlow(0.0), ADUNum(0), DesCoolingLoad(0.0), DesHeatingLoad(0.0),
               CtrlZoneNum(0), CtrlZoneInNodeIndex(0), AirLoopNum(0), OutdoorAirFlowRate(0.0)
diff --git a/src/EnergyPlus/HVACStandAloneERV.cc b/src/EnergyPlus/HVACStandAloneERV.cc
index 5ebd3dbf39a..1cc429118c6 100644
--- a/src/EnergyPlus/HVACStandAloneERV.cc
+++ b/src/EnergyPlus/HVACStandAloneERV.cc
@@ -193,7 +193,6 @@ void GetStandAloneERV(EnergyPlusData &state)
     int NodeNumber;          // used to find zone with humidistat
     int HStatZoneNum;        // used to find zone with humidistat
     int NumHstatZone;        // index to humidity controlled zones
-    Real64 HXSupAirFlowRate; // HX supply air flow rate [m3/s]
     int ZoneInletCZN;        // used for warning when zone node not listed in equipment connections
     int ZoneExhaustCZN;      // used for warning when zone node not listed in equipment connections
 
@@ -258,21 +257,16 @@ void GetStandAloneERV(EnergyPlusData &state)
 
         GlobalNames::IntraObjUniquenessCheck(
             state, Alphas(3), CurrentModuleObject, cAlphaFields(3), state.dataHVACStandAloneERV->HeatExchangerUniqueNames, ErrorsFound);
-        standAloneERV.HeatExchangerName = Alphas(3);
-        bool errFlag = false;
-        standAloneERV.hxType = HeatRecovery::GetHeatExchangerObjectTypeNum(state, standAloneERV.HeatExchangerName, errFlag);
-        if (errFlag) {
-            ShowContinueError(state, format("... occurs in {} \"{}\"", CurrentModuleObject, standAloneERV.Name));
-            ErrorsFound = true;
-        }
 
-        errFlag = false;
-        HXSupAirFlowRate = HeatRecovery::GetSupplyAirFlowRate(state, standAloneERV.HeatExchangerName, errFlag);
-        if (errFlag) {
-            ShowContinueError(state, format("... occurs in {} \"{}\"", CurrentModuleObject, standAloneERV.Name));
+        standAloneERV.hxName = Alphas(3);
+        standAloneERV.hxNum = HeatRecovery::GetHeatExchangerIndex(state, standAloneERV.hxName);
+        if (standAloneERV.hxNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(3), standAloneERV.hxName);
             ErrorsFound = true;
+        } else {
+            standAloneERV.hxType = HeatRecovery::GetHeatExchangerType(state, standAloneERV.hxNum);
+            standAloneERV.DesignHXVolFlowRate = HeatRecovery::GetSupplyAirFlowRate(state, standAloneERV.hxNum);
         }
-        standAloneERV.DesignHXVolFlowRate = HXSupAirFlowRate;
 
         standAloneERV.SupplyAirFanName = Alphas(4);
         GlobalNames::IntraObjUniquenessCheck(
@@ -306,13 +300,11 @@ void GetStandAloneERV(EnergyPlusData &state)
             standAloneERV.ExhaustAirOutletNode = fan->outletNodeNum;
         }
 
-        errFlag = false;
-        standAloneERV.SupplyAirInletNode = HeatRecovery::GetSupplyInletNode(state, standAloneERV.HeatExchangerName, errFlag);
-        standAloneERV.ExhaustAirInletNode = HeatRecovery::GetSecondaryInletNode(state, standAloneERV.HeatExchangerName, errFlag);
-        if (errFlag) {
-            ShowContinueError(state, format("... occurs in {} ={}", CurrentModuleObject, standAloneERV.Name));
-            ErrorsFound = true;
-        }
+        standAloneERV.SupplyAirInletNode = HeatRecovery::GetSupplyInletNode(state, standAloneERV.hxNum);
+        standAloneERV.ExhaustAirInletNode = HeatRecovery::GetSecondaryInletNode(state, standAloneERV.hxNum);
+
+        // What is going on here exactly?  Finding the node num using the name that you got from the node num?
+
         standAloneERV.SupplyAirInletNode = GetOnlySingleNode(state,
                                                              state.dataLoopNodes->NodeID(standAloneERV.SupplyAirInletNode),
                                                              ErrorsFound,
@@ -463,22 +455,22 @@ void GetStandAloneERV(EnergyPlusData &state)
                                      standAloneERV.ExhaustAirFanName));
         }
 
-        if (standAloneERV.SupplyAirVolFlow == DataSizing::AutoSize && HXSupAirFlowRate != DataSizing::AutoSize) {
+        if (standAloneERV.SupplyAirVolFlow == DataSizing::AutoSize && standAloneERV.DesignHXVolFlowRate != DataSizing::AutoSize) {
             ShowSevereError(state, format("{} \"{}\"", CurrentModuleObject, standAloneERV.Name));
             ShowContinueError(
                 state,
                 format("... When autosizing ERV {}, nominal supply air flow rate for heat exchanger with name = {} must also be autosized.",
                        cNumericFields(1),
-                       standAloneERV.HeatExchangerName));
+                       standAloneERV.hxName));
         }
 
-        if (standAloneERV.ExhaustAirVolFlow == DataSizing::AutoSize && HXSupAirFlowRate != DataSizing::AutoSize) {
+        if (standAloneERV.ExhaustAirVolFlow == DataSizing::AutoSize && standAloneERV.DesignHXVolFlowRate != DataSizing::AutoSize) {
             ShowSevereError(state, format("{} \"{}\"", CurrentModuleObject, standAloneERV.Name));
             ShowContinueError(
                 state,
                 format("... When autosizing ERV {}, nominal supply air flow rate for heat exchanger with name = {} must also be autosized.",
                        cNumericFields(2),
-                       standAloneERV.HeatExchangerName));
+                       standAloneERV.hxName));
         }
 
         // Compare the ERV SA flow rates to SA fan object.
@@ -574,7 +566,7 @@ void GetStandAloneERV(EnergyPlusData &state)
 
         // Add HX to component sets array
         BranchNodeConnections::SetUpCompSets(
-            state, standAloneERV.UnitType, standAloneERV.Name, "UNDEFINED", standAloneERV.HeatExchangerName, "UNDEFINED", "UNDEFINED");
+            state, standAloneERV.UnitType, standAloneERV.Name, "UNDEFINED", standAloneERV.hxName, "UNDEFINED", "UNDEFINED");
 
         // Add supply fan to component sets array
         BranchNodeConnections::SetUpCompSets(state,
@@ -596,11 +588,11 @@ void GetStandAloneERV(EnergyPlusData &state)
 
         // Verify HX name in Stand Alone ERV object matches name of valid HX object
         if (state.dataInputProcessing->inputProcessor->getObjectItemNum(
-                state, "HeatExchanger:AirToAir:SensibleAndLatent", standAloneERV.HeatExchangerName) <= 0) {
+                state, "HeatExchanger:AirToAir:SensibleAndLatent", standAloneERV.hxName) <= 0) {
             ShowSevereError(state,
                             format("{} heat exchanger type HeatExchanger:AirToAir:SensibleAndLatent not found = {}",
                                    CurrentModuleObject,
-                                   standAloneERV.HeatExchangerName));
+                                   standAloneERV.hxName));
             ErrorsFound = true;
         }
         // Verify supply air fan name in Stand Alone ERV object matches name of valid fan object
@@ -1404,27 +1396,28 @@ void CalcStandAloneERV(EnergyPlusData &state,
     bool EconomizerFlag;  // economizer signal from OA controller
     bool HighHumCtrlFlag; // high humditiy control signal from OA controller
 
-    int SupInletNode = state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SupplyAirInletNode;
-    int SupOutletNode = state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SupplyAirOutletNode;
-    int ExhaustInletNode = state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ExhaustAirInletNode;
+    auto &saERV = state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum);
+    int SupInletNode = saERV.SupplyAirInletNode;
+    int SupOutletNode = saERV.SupplyAirOutletNode;
+    int ExhaustInletNode = saERV.ExhaustAirInletNode;
 
     // Stand alone ERV's HX is ON by default
     bool HXUnitOn = true;
 
     // Get stand alone ERV's controller economizer and high humidity control status
-    if (state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ControllerNameDefined) {
-        EconomizerFlag = state.dataMixedAir->OAController(state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ControllerIndex).EconoActive;
+    if (saERV.ControllerNameDefined) {
+        EconomizerFlag = state.dataMixedAir->OAController(saERV.ControllerIndex).EconoActive;
         HighHumCtrlFlag =
-            state.dataMixedAir->OAController(state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ControllerIndex).HighHumCtrlActive;
+            state.dataMixedAir->OAController(saERV.ControllerIndex).HighHumCtrlActive;
     } else {
         EconomizerFlag = false;
         HighHumCtrlFlag = false;
     }
 
     HeatRecovery::SimHeatRecovery(state,
-                                  state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).HeatExchangerName,
+                                  saERV.hxName,
                                   FirstHVACIteration,
-                                  state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).HeatExchangerIndex,
+                                  saERV.hxNum,
                                   HVAC::FanOp::Continuous,
                                   _,
                                   HXUnitOn,
@@ -1432,15 +1425,15 @@ void CalcStandAloneERV(EnergyPlusData &state,
                                   _,
                                   EconomizerFlag,
                                   HighHumCtrlFlag);
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ElecUseRate = state.dataHVACGlobal->AirToAirHXElecPower;
+    saERV.ElecUseRate = state.dataHVACGlobal->AirToAirHXElecPower;
 
-    state.dataFans->fans(state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SupplyAirFanIndex)->simulate(state, FirstHVACIteration, _, _);
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ElecUseRate +=
-        state.dataFans->fans(state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SupplyAirFanIndex)->totalPower;
+    state.dataFans->fans(saERV.SupplyAirFanIndex)->simulate(state, FirstHVACIteration, _, _);
+    saERV.ElecUseRate +=
+        state.dataFans->fans(saERV.SupplyAirFanIndex)->totalPower;
 
-    state.dataFans->fans(state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ExhaustAirFanIndex)->simulate(state, FirstHVACIteration, _, _);
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ElecUseRate +=
-        state.dataFans->fans(state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ExhaustAirFanIndex)->totalPower;
+    state.dataFans->fans(saERV.ExhaustAirFanIndex)->simulate(state, FirstHVACIteration, _, _);
+    saERV.ElecUseRate +=
+        state.dataFans->fans(saERV.ExhaustAirFanIndex)->totalPower;
 
     // total mass flow through supply side of the ERV (supply air outlet node)
     Real64 AirMassFlow = state.dataLoopNodes->Node(SupOutletNode).MassFlowRate;
@@ -1456,42 +1449,42 @@ void CalcStandAloneERV(EnergyPlusData &state,
                                        state.dataLoopNodes->Node(ExhaustInletNode).HumRat); // kg/s, dehumidification = negative
 
     if (SensLoadMet < 0.0) {
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensCoolingRate = std::abs(SensLoadMet);
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensHeatingRate = 0.0;
+        saERV.SensCoolingRate = std::abs(SensLoadMet);
+        saERV.SensHeatingRate = 0.0;
     } else {
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensCoolingRate = 0.0;
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensHeatingRate = SensLoadMet;
+        saERV.SensCoolingRate = 0.0;
+        saERV.SensHeatingRate = SensLoadMet;
     }
     if (TotLoadMet < 0.0) {
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotCoolingRate = std::abs(TotLoadMet);
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotHeatingRate = 0.0;
+        saERV.TotCoolingRate = std::abs(TotLoadMet);
+        saERV.TotHeatingRate = 0.0;
     } else {
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotCoolingRate = 0.0;
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotHeatingRate = TotLoadMet;
+        saERV.TotCoolingRate = 0.0;
+        saERV.TotHeatingRate = TotLoadMet;
     }
     if (LatLoadMet < 0.0) {
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatCoolingRate = std::abs(LatLoadMet);
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatHeatingRate = 0.0;
+        saERV.LatCoolingRate = std::abs(LatLoadMet);
+        saERV.LatHeatingRate = 0.0;
     } else {
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatCoolingRate = 0.0;
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatHeatingRate = LatLoadMet;
+        saERV.LatCoolingRate = 0.0;
+        saERV.LatHeatingRate = LatLoadMet;
     }
 
     // Provide a one time message when exhaust flow rate is greater than supply flow rate
-    if (state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).FlowError && !state.dataGlobal->WarmupFlag) {
+    if (saERV.FlowError && !state.dataGlobal->WarmupFlag) {
         Real64 TotalExhaustMassFlow = state.dataLoopNodes->Node(ExhaustInletNode).MassFlowRate;
         Real64 TotalSupplyMassFlow = state.dataLoopNodes->Node(SupInletNode).MassFlowRate;
         if (TotalExhaustMassFlow > TotalSupplyMassFlow && !state.dataHeatBal->ZoneAirMassFlow.EnforceZoneMassBalance) {
             ShowWarningError(state,
                              format("For {} \"{}\" there is unbalanced exhaust air flow.",
-                                    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).UnitType,
-                                    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).Name));
+                                    saERV.UnitType,
+                                    saERV.Name));
             ShowContinueError(state, format("... The exhaust air mass flow rate = {:.6R}", state.dataLoopNodes->Node(ExhaustInletNode).MassFlowRate));
             ShowContinueError(state, format("... The  supply air mass flow rate = {:.6R}", state.dataLoopNodes->Node(SupInletNode).MassFlowRate));
             ShowContinueErrorTimeStamp(state, "");
             ShowContinueError(state, "... Unless there is balancing infiltration / ventilation air flow, this will result in");
             ShowContinueError(state, "... load due to induced outside air being neglected in the simulation.");
-            state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).FlowError = false;
+            saERV.FlowError = false;
         }
     }
 }
@@ -1504,25 +1497,19 @@ void ReportStandAloneERV(EnergyPlusData &state, int const StandAloneERVNum) // n
     //       DATE WRITTEN   June 2003
 
     Real64 ReportingConstant = state.dataHVACGlobal->TimeStepSysSec;
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ElecUseEnergy =
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).ElecUseRate * ReportingConstant;
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensCoolingEnergy =
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensCoolingRate * ReportingConstant;
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatCoolingEnergy =
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatCoolingRate * ReportingConstant;
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotCoolingEnergy =
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotCoolingRate * ReportingConstant;
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensHeatingEnergy =
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).SensHeatingRate * ReportingConstant;
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatHeatingEnergy =
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).LatHeatingRate * ReportingConstant;
-    state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotHeatingEnergy =
-        state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).TotHeatingRate * ReportingConstant;
-
-    if (state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).FirstPass) { // reset sizing flags so other zone equipment can size normally
+    auto &saERV = state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum);
+    
+    saERV.ElecUseEnergy = saERV.ElecUseRate * ReportingConstant;
+    saERV.SensCoolingEnergy = saERV.SensCoolingRate * ReportingConstant;
+    saERV.LatCoolingEnergy = saERV.LatCoolingRate * ReportingConstant;
+    saERV.TotCoolingEnergy = saERV.TotCoolingRate * ReportingConstant;
+    saERV.SensHeatingEnergy = saERV.SensHeatingRate * ReportingConstant;
+    saERV.LatHeatingEnergy = saERV.LatHeatingRate * ReportingConstant;
+    saERV.TotHeatingEnergy = saERV.TotHeatingRate * ReportingConstant;
+
+    if (saERV.FirstPass) { // reset sizing flags so other zone equipment can size normally
         if (!state.dataGlobal->SysSizingCalc) {
-            DataSizing::resetHVACSizingGlobals(
-                state, state.dataSize->CurZoneEqNum, 0, state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).FirstPass);
+            DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, 0, saERV.FirstPass);
         }
     }
 }
diff --git a/src/EnergyPlus/HVACStandAloneERV.hh b/src/EnergyPlus/HVACStandAloneERV.hh
index 7516a2b9a42..09c1a90be5e 100644
--- a/src/EnergyPlus/HVACStandAloneERV.hh
+++ b/src/EnergyPlus/HVACStandAloneERV.hh
@@ -73,9 +73,11 @@ namespace HVACStandAloneERV {
         std::string Name;                              // name of the stand alone ERV unit
         std::string UnitType;                          // ZoneHVAC:EnergyRecoveryVentilator
         Sched::Schedule *availSched = nullptr;         // availability schedule
-        std::string HeatExchangerName;                 // name of the heat exchanger within the ERV unit
-        int HeatExchangerIndex;                        // Pointer to heat exchanger
+
+        std::string hxName;                 // name of the heat exchanger within the ERV unit
+        int hxNum = 0;                        // Pointer to heat exchanger
         HVAC::HXType hxType = HVAC::HXType::Invalid;   // Parameter equivalent of HX object type
+      
         int SupplyAirInletNode;                        // supply air inlet node for the stand alone ERV
         int SupplyAirOutletNode;                       // supply air outlet node for the stand alone ERV
         std::string SupplyAirFanName;                  // fan name in the supply air stream of the ERV
@@ -127,7 +129,7 @@ namespace HVACStandAloneERV {
 
         // Default Constructor
         StandAloneERVData()
-            : HeatExchangerIndex(0), SupplyAirInletNode(0), SupplyAirOutletNode(0), SupplyAirFanIndex(0), supplyAirFanType(HVAC::FanType::Invalid),
+            : SupplyAirInletNode(0), SupplyAirOutletNode(0), SupplyAirFanIndex(0), supplyAirFanType(HVAC::FanType::Invalid),
               ExhaustAirInletNode(0), ExhaustAirOutletNode(0), ExhaustAirFanIndex(0), exhaustAirFanType(HVAC::FanType::Invalid),
               SupplyAirVolFlow(0.0), ExhaustAirVolFlow(0.0), ControllerNameDefined(false), ControlledZoneNum(0), ControllerIndex(0),
               MaxSupAirMassFlow(0.0), MaxExhAirMassFlow(0.0), HighRHOAFlowRatio(1.0), DesignSAFanVolFlowRate(0.0), DesignEAFanVolFlowRate(0.0),
diff --git a/src/EnergyPlus/HVACUnitaryBypassVAV.cc b/src/EnergyPlus/HVACUnitaryBypassVAV.cc
index c3bea79397d..cf4b187cc26 100644
--- a/src/EnergyPlus/HVACUnitaryBypassVAV.cc
+++ b/src/EnergyPlus/HVACUnitaryBypassVAV.cc
@@ -152,7 +152,7 @@ namespace HVACUnitaryBypassVAV {
 
         // Find the correct changeover-bypass VAV unit
         if (CompIndex == 0) {
-            CBVAVNum = Util::FindItemInList(CompName, state.dataHVACUnitaryBypassVAV->CBVAV);
+            CBVAVNum = Util::FindItemInList(CompName, state.dataHVACUnitaryBypassVAV->CBVAVs);
             if (CBVAVNum == 0) {
                 ShowFatalError(state, format("SimUnitaryBypassVAV: Unit not found={}", CompName));
             }
@@ -167,12 +167,12 @@ namespace HVACUnitaryBypassVAV {
                                       CompName));
             }
             if (state.dataHVACUnitaryBypassVAV->CheckEquipName(CBVAVNum)) {
-                if (CompName != state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum).Name) {
+                if (CompName != state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum).Name) {
                     ShowFatalError(state,
                                    format("SimUnitaryBypassVAV: Invalid CompIndex passed={}, Unit name={}, stored Unit Name for that index={}",
                                           CBVAVNum,
                                           CompName,
-                                          state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum).Name));
+                                          state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum).Name));
                 }
                 state.dataHVACUnitaryBypassVAV->CheckEquipName(CBVAVNum) = false;
             }
@@ -212,7 +212,7 @@ namespace HVACUnitaryBypassVAV {
 
         QSensUnitOut = 0.0; // probably don't need this initialization
 
-        auto &changeOverByPassVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &changeOverByPassVAV = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
         // zero the fan and DX coils electricity consumption
         state.dataHVACGlobal->DXElecCoolingPower = 0.0;
@@ -284,13 +284,13 @@ namespace HVACUnitaryBypassVAV {
 
         Real64 HeatingPower = 0.0; // DX Htg coil Plus CrankCase electric power use or electric heating coil [W]
         Real64 locDefrostPower = 0.0;
-        if (changeOverByPassVAV.HeatCoilType == HVAC::CoilType::DXHeatingEmpirical) {
+        if (changeOverByPassVAV.heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
             HeatingPower = state.dataHVACGlobal->DXElecHeatingPower;
             locDefrostPower = state.dataHVACGlobal->DefrostElecPower;
-        } else if (changeOverByPassVAV.HeatCoilType == HVAC::CoilType::HeatingAirToAirVariableSpeed) {
+        } else if (changeOverByPassVAV.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
             HeatingPower = state.dataHVACGlobal->DXElecHeatingPower;
             locDefrostPower = state.dataHVACGlobal->DefrostElecPower;
-        } else if (changeOverByPassVAV.HeatCoilType == HVAC::CoilType::HeatingElectric) {
+        } else if (changeOverByPassVAV.heatCoilType == HVAC::CoilType::HeatingElectric) {
             HeatingPower = state.dataHVACGlobal->ElecHeatingCoilPower;
         } else {
             HeatingPower = 0.0;
@@ -317,7 +317,6 @@ namespace HVACUnitaryBypassVAV {
 
         // SUBROUTINE PARAMETER DEFINITIONS:
         static constexpr std::string_view routineName = "GetCBVAV";
-        static constexpr std::string_view getUnitaryHeatCoolVAVChangeoverBypass("GetUnitaryHeatCool:VAVChangeoverBypass");
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         int NumAlphas;                // Number of Alphas for each GetObjectItem call
@@ -340,12 +339,14 @@ namespace HVACUnitaryBypassVAV {
         // find the number of each type of CBVAV unit
         std::string CurrentModuleObject = "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass";
 
+        auto &s_node = state.dataLoopNodes;
+        
         // Update Num in state and make local convenience copy
         int NumCBVAV = state.dataHVACUnitaryBypassVAV->NumCBVAV =
             state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject);
 
         // allocate the data structures
-        state.dataHVACUnitaryBypassVAV->CBVAV.resize(NumCBVAV);
+        state.dataHVACUnitaryBypassVAV->CBVAVs.resize(NumCBVAV);
         state.dataHVACUnitaryBypassVAV->CheckEquipName.dimension(NumCBVAV, true);
 
         // loop over CBVAV units; get and load the input data
@@ -363,77 +364,77 @@ namespace HVACUnitaryBypassVAV {
                                                                      cAlphaFields,
                                                                      cNumericFields);
 
-            auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+            auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
-            thisCBVAV.Name = Alphas(1);
+            cbvav.Name = Alphas(1);
 
-            ErrorObjectHeader eoh{routineName, CurrentModuleObject, thisCBVAV.Name};
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, cbvav.Name};
 
-            thisCBVAV.UnitType = CurrentModuleObject;
+            cbvav.UnitType = CurrentModuleObject;
             if (lAlphaBlanks(2)) {
-                thisCBVAV.availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((thisCBVAV.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                cbvav.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((cbvav.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
                 ErrorsFound = true;
             }
 
-            thisCBVAV.MaxCoolAirVolFlow = Numbers(1);
-            if (thisCBVAV.MaxCoolAirVolFlow <= 0.0 && thisCBVAV.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+            cbvav.MaxCoolAirVolFlow = Numbers(1);
+            if (cbvav.MaxCoolAirVolFlow <= 0.0 && cbvav.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} illegal {} = {:.7T}", CurrentModuleObject, cNumericFields(1), Numbers(1)));
                 ShowContinueError(state, format("{} must be greater than zero.", cNumericFields(1)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             }
 
-            thisCBVAV.MaxHeatAirVolFlow = Numbers(2);
-            if (thisCBVAV.MaxHeatAirVolFlow <= 0.0 && thisCBVAV.MaxHeatAirVolFlow != DataSizing::AutoSize) {
+            cbvav.MaxHeatAirVolFlow = Numbers(2);
+            if (cbvav.MaxHeatAirVolFlow <= 0.0 && cbvav.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} illegal {} = {:.7T}", CurrentModuleObject, cNumericFields(2), Numbers(2)));
                 ShowContinueError(state, format("{} must be greater than zero.", cNumericFields(2)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             }
 
-            thisCBVAV.MaxNoCoolHeatAirVolFlow = Numbers(3);
-            if (thisCBVAV.MaxNoCoolHeatAirVolFlow < 0.0 && thisCBVAV.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
+            cbvav.MaxNoCoolHeatAirVolFlow = Numbers(3);
+            if (cbvav.MaxNoCoolHeatAirVolFlow < 0.0 && cbvav.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} illegal {} = {:.7T}", CurrentModuleObject, cNumericFields(3), Numbers(3)));
                 ShowContinueError(state, format("{} must be greater than or equal to zero.", cNumericFields(3)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             }
 
-            thisCBVAV.CoolOutAirVolFlow = Numbers(4);
-            if (thisCBVAV.CoolOutAirVolFlow < 0.0 && thisCBVAV.CoolOutAirVolFlow != DataSizing::AutoSize) {
+            cbvav.CoolOutAirVolFlow = Numbers(4);
+            if (cbvav.CoolOutAirVolFlow < 0.0 && cbvav.CoolOutAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} illegal {} = {:.7T}", CurrentModuleObject, cNumericFields(4), Numbers(4)));
                 ShowContinueError(state, format("{} must be greater than or equal to zero.", cNumericFields(4)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             }
 
-            thisCBVAV.HeatOutAirVolFlow = Numbers(5);
-            if (thisCBVAV.HeatOutAirVolFlow < 0.0 && thisCBVAV.HeatOutAirVolFlow != DataSizing::AutoSize) {
+            cbvav.HeatOutAirVolFlow = Numbers(5);
+            if (cbvav.HeatOutAirVolFlow < 0.0 && cbvav.HeatOutAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} illegal {} = {:.7T}", CurrentModuleObject, cNumericFields(5), Numbers(5)));
                 ShowContinueError(state, format("{} must be greater than or equal to zero.", cNumericFields(5)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             }
 
-            thisCBVAV.NoCoolHeatOutAirVolFlow = Numbers(6);
-            if (thisCBVAV.NoCoolHeatOutAirVolFlow < 0.0 && thisCBVAV.NoCoolHeatOutAirVolFlow != DataSizing::AutoSize) {
+            cbvav.NoCoolHeatOutAirVolFlow = Numbers(6);
+            if (cbvav.NoCoolHeatOutAirVolFlow < 0.0 && cbvav.NoCoolHeatOutAirVolFlow != DataSizing::AutoSize) {
                 ShowSevereError(state, format("{} illegal {} = {:.7T}", CurrentModuleObject, cNumericFields(6), Numbers(6)));
                 ShowContinueError(state, format("{} must be greater than or equal to zero.", cNumericFields(6)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             }
 
-            thisCBVAV.outAirSched = Sched::GetSchedule(state, Alphas(3));
-            if (thisCBVAV.outAirSched != nullptr) {
-                if (!thisCBVAV.outAirSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
+            cbvav.outAirSched = Sched::GetSchedule(state, Alphas(3));
+            if (cbvav.outAirSched != nullptr) {
+                if (!cbvav.outAirSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
                     Sched::ShowSevereBadMinMax(state, eoh, cAlphaFields(3), Alphas(3), Clusive::In, 0.0, Clusive::In, 1.0);
                     ErrorsFound = true;
                 }
             }
 
-            thisCBVAV.AirInNode =
+            cbvav.AirInNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     Alphas(4),
                                                     ErrorsFound,
@@ -447,7 +448,7 @@ namespace HVACUnitaryBypassVAV {
             std::string MixerInletNodeName = Alphas(5);
             std::string SplitterOutletNodeName = Alphas(6);
 
-            thisCBVAV.AirOutNode =
+            cbvav.AirOutNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     Alphas(7),
                                                     ErrorsFound,
@@ -458,7 +459,7 @@ namespace HVACUnitaryBypassVAV {
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
 
-            thisCBVAV.SplitterOutletAirNode =
+            cbvav.SplitterOutletAirNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     SplitterOutletNodeName,
                                                     ErrorsFound,
@@ -470,7 +471,7 @@ namespace HVACUnitaryBypassVAV {
                                                     DataLoopNode::ObjectIsParent);
 
             if (NumAlphas > 19 && !lAlphaBlanks(20)) {
-                thisCBVAV.PlenumMixerInletAirNode =
+                cbvav.PlenumMixerInletAirNode =
                     NodeInputManager::GetOnlySingleNode(state,
                                                         Alphas(20),
                                                         ErrorsFound,
@@ -480,7 +481,7 @@ namespace HVACUnitaryBypassVAV {
                                                         DataLoopNode::ConnectionType::Internal,
                                                         NodeInputManager::CompFluidStream::Primary,
                                                         DataLoopNode::ObjectIsParent);
-                thisCBVAV.PlenumMixerInletAirNode =
+                cbvav.PlenumMixerInletAirNode =
                     NodeInputManager::GetOnlySingleNode(state,
                                                         Alphas(20),
                                                         ErrorsFound,
@@ -492,16 +493,16 @@ namespace HVACUnitaryBypassVAV {
                                                         DataLoopNode::ObjectIsParent);
             }
 
-            thisCBVAV.plenumIndex = ZonePlenum::getReturnPlenumIndexFromInletNode(state, thisCBVAV.PlenumMixerInletAirNode);
-            thisCBVAV.mixerIndex = MixerComponent::getZoneMixerIndexFromInletNode(state, thisCBVAV.PlenumMixerInletAirNode);
-            if (thisCBVAV.plenumIndex > 0 && thisCBVAV.mixerIndex > 0) {
-                ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            cbvav.plenumIndex = ZonePlenum::getReturnPlenumIndexFromInletNode(state, cbvav.PlenumMixerInletAirNode);
+            cbvav.mixerIndex = MixerComponent::getZoneMixerIndexFromInletNode(state, cbvav.PlenumMixerInletAirNode);
+            if (cbvav.plenumIndex > 0 && cbvav.mixerIndex > 0) {
+                ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                 ShowContinueError(state, format("Illegal connection for {} = \"{}\".", cAlphaFields(20), Alphas(20)));
                 ShowContinueError(
                     state, format("{} cannot be connected to both an AirloopHVAC:ReturnPlenum and an AirloopHVAC:ZoneMixer.", cAlphaFields(20)));
                 ErrorsFound = true;
-            } else if (thisCBVAV.plenumIndex == 0 && thisCBVAV.mixerIndex == 0 && thisCBVAV.PlenumMixerInletAirNode > 0) {
-                ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            } else if (cbvav.plenumIndex == 0 && cbvav.mixerIndex == 0 && cbvav.PlenumMixerInletAirNode > 0) {
+                ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                 ShowContinueError(state, format("Illegal connection for {} = \"{}\".", cAlphaFields(20), Alphas(20)));
                 ShowContinueError(
                     state,
@@ -509,7 +510,7 @@ namespace HVACUnitaryBypassVAV {
                 ErrorsFound = true;
             }
 
-            thisCBVAV.MixerInletAirNode =
+            cbvav.MixerInletAirNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     MixerInletNodeName,
                                                     ErrorsFound,
@@ -520,7 +521,7 @@ namespace HVACUnitaryBypassVAV {
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
 
-            thisCBVAV.MixerInletAirNode =
+            cbvav.MixerInletAirNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     MixerInletNodeName,
                                                     ErrorsFound,
@@ -531,7 +532,7 @@ namespace HVACUnitaryBypassVAV {
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
 
-            thisCBVAV.SplitterOutletAirNode =
+            cbvav.SplitterOutletAirNode =
                 NodeInputManager::GetOnlySingleNode(state,
                                                     SplitterOutletNodeName,
                                                     ErrorsFound,
@@ -542,535 +543,490 @@ namespace HVACUnitaryBypassVAV {
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsParent);
 
-            thisCBVAV.OAMixType = Alphas(8);
-            thisCBVAV.OAMixName = Alphas(9);
+            cbvav.OAMixType = Alphas(8);
+            cbvav.OAMixName = Alphas(9);
 
             bool errFlag = false;
-            ValidateComponent(state, thisCBVAV.OAMixType, thisCBVAV.OAMixName, errFlag, CurrentModuleObject);
+            ValidateComponent(state, cbvav.OAMixType, cbvav.OAMixName, errFlag, CurrentModuleObject);
             if (errFlag) {
-                ShowContinueError(state, format("specified in {} = \"{}\".", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("specified in {} = \"{}\".", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             } else {
                 // Get OA Mixer node numbers
-                OANodeNums = MixedAir::GetOAMixerNodeNumbers(state, thisCBVAV.OAMixName, errFlag);
+                OANodeNums = MixedAir::GetOAMixerNodeNumbers(state, cbvav.OAMixName, errFlag);
                 if (errFlag) {
-                    ShowContinueError(state, format("that was specified in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                    ShowContinueError(state, format("that was specified in {} = {}", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state, "..OutdoorAir:Mixer is required. Enter an OutdoorAir:Mixer object with this name.");
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.MixerOutsideAirNode = OANodeNums(1);
-                    thisCBVAV.MixerReliefAirNode = OANodeNums(2);
-                    // thisCBVAV%MixerInletAirNode  = OANodeNums(3)
-                    thisCBVAV.MixerMixedAirNode = OANodeNums(4);
+                    cbvav.MixerOutsideAirNode = OANodeNums(1);
+                    cbvav.MixerReliefAirNode = OANodeNums(2);
+                    // cbvav%MixerInletAirNode  = OANodeNums(3)
+                    cbvav.MixerMixedAirNode = OANodeNums(4);
                 }
             }
 
-            if (thisCBVAV.MixerInletAirNode != OANodeNums(3)) {
-                ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            if (cbvav.MixerInletAirNode != OANodeNums(3)) {
+                ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                 ShowContinueError(state, format("Illegal {} = {}.", cAlphaFields(5), MixerInletNodeName));
                 ShowContinueError(
                     state, format("{} must be the same as the return air stream node specified in the OutdoorAir:Mixer object.", cAlphaFields(5)));
                 ErrorsFound = true;
             }
 
-            if (thisCBVAV.MixerInletAirNode == thisCBVAV.AirInNode) {
-                ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            if (cbvav.MixerInletAirNode == cbvav.AirInNode) {
+                ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                 ShowContinueError(state, format("Illegal {} = {}.", cAlphaFields(5), MixerInletNodeName));
                 ShowContinueError(state, format("{} must be different than the {}.", cAlphaFields(5), cAlphaFields(4)));
                 ErrorsFound = true;
             }
 
-            if (thisCBVAV.SplitterOutletAirNode == thisCBVAV.AirOutNode) {
-                ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            if (cbvav.SplitterOutletAirNode == cbvav.AirOutNode) {
+                ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                 ShowContinueError(state, format("Illegal {} = {}.", cAlphaFields(6), SplitterOutletNodeName));
                 ShowContinueError(state, format("{} must be different than the {}.", cAlphaFields(6), cAlphaFields(7)));
                 ErrorsFound = true;
             }
 
             // required field must be Key=Fan:ConstantVolume, Fan:OnOff or Fan:SystemModel and read in as upper case
-            thisCBVAV.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(10)));
-            assert(thisCBVAV.fanType != HVAC::FanType::Invalid);
+            cbvav.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(10)));
+            assert(cbvav.fanType != HVAC::FanType::Invalid);
 
-            thisCBVAV.FanName = Alphas(11);
+            cbvav.FanName = Alphas(11);
             int fanOutletNode(0);
 
             // check that the fan exists
-            if ((thisCBVAV.FanIndex = Fans::GetFanIndex(state, thisCBVAV.FanName)) == 0) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(11), thisCBVAV.FanName);
+            if ((cbvav.FanIndex = Fans::GetFanIndex(state, cbvav.FanName)) == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(11), cbvav.FanName);
                 ErrorsFound = true;
-                thisCBVAV.FanVolFlow = 9999.0;
+                cbvav.FanVolFlow = 9999.0;
             } else {
-                auto *fan = state.dataFans->fans(thisCBVAV.FanIndex);
-                thisCBVAV.FanInletNodeNum = fan->inletNodeNum;
+                auto *fan = state.dataFans->fans(cbvav.FanIndex);
+                cbvav.FanInletNodeNum = fan->inletNodeNum;
                 fanOutletNode = fan->outletNodeNum;
-                thisCBVAV.FanVolFlow = fan->maxAirFlowRate;
+                cbvav.FanVolFlow = fan->maxAirFlowRate;
             }
 
             // required field must be Key=BlowThrough or DrawThrough and read in as BLOWTHROUGH or DRAWTHROUGH
-            thisCBVAV.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(12)));
+            cbvav.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(12)));
 
-            if (thisCBVAV.fanPlace == HVAC::FanPlace::DrawThru) {
-                if (thisCBVAV.SplitterOutletAirNode != fanOutletNode) {
-                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            if (cbvav.fanPlace == HVAC::FanPlace::DrawThru) {
+                if (cbvav.SplitterOutletAirNode != fanOutletNode) {
+                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state, format("Illegal {} = {}.", cAlphaFields(6), SplitterOutletNodeName));
                     ShowContinueError(state,
                                       format("{} must be the same as the fan outlet node specified in {} = {}: {} when draw through {} is selected.",
                                              cAlphaFields(6),
                                              cAlphaFields(10),
                                              Alphas(10),
-                                             thisCBVAV.FanName,
+                                             cbvav.FanName,
                                              cAlphaFields(11)));
                     ErrorsFound = true;
                 }
             }
 
-            if (thisCBVAV.FanVolFlow != DataSizing::AutoSize) {
-                if (thisCBVAV.FanVolFlow < thisCBVAV.MaxCoolAirVolFlow && thisCBVAV.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+            if (cbvav.FanVolFlow != DataSizing::AutoSize) {
+                if (cbvav.FanVolFlow < cbvav.MaxCoolAirVolFlow && cbvav.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in {} = {} is less than the ",
                                             CurrentModuleObject,
-                                            thisCBVAV.FanVolFlow,
+                                            cbvav.FanVolFlow,
                                             cAlphaFields(11),
-                                            thisCBVAV.FanName) +
+                                            cbvav.FanName) +
                                          cNumericFields(1));
                     ShowContinueError(state, format(" {} is reset to the fan flow rate and the simulation continues.", cNumericFields(1)));
-                    ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
-                    thisCBVAV.MaxCoolAirVolFlow = thisCBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
+                    cbvav.MaxCoolAirVolFlow = cbvav.FanVolFlow;
                 }
-                if (thisCBVAV.FanVolFlow < thisCBVAV.MaxHeatAirVolFlow && thisCBVAV.MaxHeatAirVolFlow != DataSizing::AutoSize) {
+                if (cbvav.FanVolFlow < cbvav.MaxHeatAirVolFlow && cbvav.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in {} = {} is less than the ",
                                             CurrentModuleObject,
-                                            thisCBVAV.FanVolFlow,
+                                            cbvav.FanVolFlow,
                                             cAlphaFields(11),
-                                            thisCBVAV.FanName) +
+                                            cbvav.FanName) +
                                          cNumericFields(2));
                     ShowContinueError(state, format(" {} is reset to the fan flow rate and the simulation continues.", cNumericFields(2)));
-                    ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
-                    thisCBVAV.MaxHeatAirVolFlow = thisCBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
+                    cbvav.MaxHeatAirVolFlow = cbvav.FanVolFlow;
                 }
             }
 
             //   only check that OA flow in cooling is >= SA flow in cooling when they are not autosized
-            if (thisCBVAV.CoolOutAirVolFlow > thisCBVAV.MaxCoolAirVolFlow && thisCBVAV.CoolOutAirVolFlow != DataSizing::AutoSize &&
-                thisCBVAV.MaxCoolAirVolFlow != DataSizing::AutoSize) {
+            if (cbvav.CoolOutAirVolFlow > cbvav.MaxCoolAirVolFlow && cbvav.CoolOutAirVolFlow != DataSizing::AutoSize &&
+                cbvav.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                 ShowWarningError(state, format("{}: {} cannot be greater than {}", CurrentModuleObject, cNumericFields(4), cNumericFields(1)));
                 ShowContinueError(state, format(" {} is reset to the fan flow rate and the simulation continues.", cNumericFields(4)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
-                thisCBVAV.CoolOutAirVolFlow = thisCBVAV.FanVolFlow;
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
+                cbvav.CoolOutAirVolFlow = cbvav.FanVolFlow;
             }
 
             //   only check that SA flow in heating is >= OA flow in heating when they are not autosized
-            if (thisCBVAV.HeatOutAirVolFlow > thisCBVAV.MaxHeatAirVolFlow && thisCBVAV.HeatOutAirVolFlow != DataSizing::AutoSize &&
-                thisCBVAV.MaxHeatAirVolFlow != DataSizing::AutoSize) {
+            if (cbvav.HeatOutAirVolFlow > cbvav.MaxHeatAirVolFlow && cbvav.HeatOutAirVolFlow != DataSizing::AutoSize &&
+                cbvav.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                 ShowWarningError(state, format("{}: {} cannot be greater than {}", CurrentModuleObject, cNumericFields(5), cNumericFields(2)));
                 ShowContinueError(state, format(" {} is reset to the fan flow rate and the simulation continues.", cNumericFields(5)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
-                thisCBVAV.HeatOutAirVolFlow = thisCBVAV.FanVolFlow;
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
+                cbvav.HeatOutAirVolFlow = cbvav.FanVolFlow;
             }
 
-            std::string thisCoolCoilType = Alphas(14);
-            thisCBVAV.CoolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, thisCoolCoilType));
-            thisCBVAV.DXCoolCoilName = Alphas(15);
+            cbvav.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(14)));
+            cbvav.CoolCoilName = Alphas(15);
 
-            if (thisCBVAV.CoolCoilType == HVAC::CoilType::DXCoolingSingleSpeed) {
-                DXCoilErrFlag = false;
-                DXCoils::GetDXCoilIndex(state, thisCBVAV.DXCoolCoilName, thisCBVAV.DXCoolCoilIndexNum, DXCoilErrFlag, thisCoolCoilType);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+            if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                cbvav.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                cbvav.CoolCoilNum = DXCoils::GetCoilIndex(state, cbvav.CoolCoilName);
+                if (cbvav.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(15), cbvav.CoolCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.DXCoilInletNode = state.dataDXCoils->DXCoil(thisCBVAV.DXCoolCoilIndexNum).AirInNode;
-                    thisCBVAV.DXCoilOutletNode = state.dataDXCoils->DXCoil(thisCBVAV.DXCoolCoilIndexNum).AirOutNode;
-                    thisCBVAV.CondenserNodeNum = state.dataDXCoils->DXCoil(thisCBVAV.DXCoolCoilIndexNum).CondenserInletNodeNum(1);
-                }
-            } else if (thisCBVAV.CoolCoilType == HVAC::CoilType::CoolingAirToAirVariableSpeed) {
-                DXCoilErrFlag = false;
-                thisCBVAV.DXCoolCoilIndexNum =
-                    VariableSpeedCoils::GetCoilIndexVariableSpeed(state, thisCoolCoilType, thisCBVAV.DXCoolCoilName, DXCoilErrFlag);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+                    auto const &dxCoil = state.dataDXCoils->DXCoil(cbvav.CoolCoilNum);
+                    cbvav.CoolCoilAirInletNode = dxCoil.AirInNode;
+                    cbvav.CoolCoilAirOutletNode = dxCoil.AirOutNode;
+                    cbvav.CondenserNodeNum = dxCoil.CondenserInletNodeNum(1);
+                }
+                
+            } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                cbvav.CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, cbvav.CoolCoilName);
+                if (cbvav.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(15), cbvav.CoolCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.DXCoilInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXCoolCoilIndexNum).AirInletNodeNum;
-                    thisCBVAV.DXCoilOutletNode = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXCoolCoilIndexNum).AirOutletNodeNum;
-                    thisCBVAV.CondenserNodeNum = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXCoolCoilIndexNum).CondenserInletNodeNum;
-                }
-            } else if (thisCBVAV.CoolCoilType == HVAC::CoilType::DXCoolingHXAssisted) {
-                DXCoilErrFlag = false;
-                int ActualCoolCoilType =
-                    HVACHXAssistedCoolingCoil::GetCoilObjectTypeNum(state, thisCoolCoilType, thisCBVAV.DXCoolCoilName, DXErrorsFound);
-                if (DXErrorsFound) {
-                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
-                    ShowContinueError(state, format("CoilSystem:Cooling:DX:HeatExchangerAssisted \"{}\" not found.", thisCBVAV.DXCoolCoilName));
+                    auto const &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(cbvav.CoolCoilNum);
+                    cbvav.CoolCoilAirInletNode = vsCoil.AirInletNodeNum;
+                    cbvav.CoolCoilAirOutletNode = vsCoil.AirOutletNodeNum;
+                    cbvav.CondenserNodeNum = vsCoil.CondenserInletNodeNum;
+                }
+                
+            } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+              // For an HXAssisted coil, these variables get bumped
+              // over to hxCoolCoil so that CoolCoil variables can
+              // refer to the actual child DX coil
+                cbvav.CoolCoilNum = HXAssistCoil::GetCoilIndex(state, cbvav.CoolCoilName);
+                if (cbvav.CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(15), cbvav.CoolCoilName);
                     ErrorsFound = true;
                 } else {
-                    if (ActualCoolCoilType == HVAC::CoilDX_CoolingSingleSpeed) {
-                        DXCoils::GetDXCoilIndex(
-                            state,
-                            HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, thisCoolCoilType, thisCBVAV.DXCoolCoilName, DXCoilErrFlag),
-                            thisCBVAV.DXCoolCoilIndexNum,
-                            DXCoilErrFlag,
-                            "Coil:Cooling:DX:SingleSpeed");
-                        if (DXCoilErrFlag) {
-                            ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
-                            ErrorsFound = true;
-                        } else {
-                            // the "coil" nodes are actually the parent nodes of the wrapped HX
-                            thisCBVAV.DXCoilInletNode =
-                                HVACHXAssistedCoolingCoil::GetCoilInletNode(state, thisCoolCoilType, thisCBVAV.DXCoolCoilName, DXErrorsFound);
-                            thisCBVAV.DXCoilOutletNode =
-                                HVACHXAssistedCoolingCoil::GetCoilOutletNode(state, thisCoolCoilType, thisCBVAV.DXCoolCoilName, DXErrorsFound);
-                            // the DX coil holds the condenser inlet node number
-                            thisCBVAV.CondenserNodeNum = state.dataDXCoils->DXCoil(thisCBVAV.DXCoolCoilIndexNum).CondenserInletNodeNum(1);
-                        }
-                    } else if (ActualCoolCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                        thisCBVAV.DXCoolCoilIndexNum = VariableSpeedCoils::GetCoilIndexVariableSpeed(
-                            state,
-                            "Coil:Cooling:DX:VariableSpeed",
-                            HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, thisCoolCoilType, thisCBVAV.DXCoolCoilName, DXCoilErrFlag),
-                            DXCoilErrFlag);
-                        if (DXCoilErrFlag) {
-                            ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
-                            ErrorsFound = true;
-                        } else {
-                            thisCBVAV.DXCoilInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXCoolCoilIndexNum).AirInletNodeNum;
-                            thisCBVAV.DXCoilOutletNode = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXCoolCoilIndexNum).AirOutletNodeNum;
-                            thisCBVAV.CondenserNodeNum =
-                                state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXCoolCoilIndexNum).CondenserInletNodeNum;
-                        }
-                    } else if (ActualCoolCoilType == HVAC::CoilDX_Cooling) {
-                        thisCBVAV.DXCoolCoilIndexNum = CoilCoolingDX::factory(state, thisCBVAV.DXCoolCoilName);
-                        if (thisCBVAV.DXCoolCoilIndexNum == -1) {
-                            ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
-                            ErrorsFound = true;
-                        } else {
-                            auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[thisCBVAV.DXCoolCoilIndexNum];
-                            thisCBVAV.DXCoilInletNode = newCoil.evapInletNodeIndex;
-                            thisCBVAV.DXCoilOutletNode = newCoil.evapOutletNodeIndex;
-                            thisCBVAV.CondenserNodeNum = newCoil.condInletNodeIndex;
-                        }
-                    }
-                }
-            } else if (thisCBVAV.CoolCoilType == HVAC::CoilType::DXCoolingTwoStageWHumControl) {
-                DXCoilErrFlag = false;
-                DXCoils::GetDXCoilIndex(state, thisCBVAV.DXCoolCoilName, thisCBVAV.DXCoolCoilIndexNum, DXCoilErrFlag, thisCoolCoilType);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
-                    ErrorsFound = true;
-                } else {
-                    thisCBVAV.DXCoilInletNode = state.dataDXCoils->DXCoil(thisCBVAV.DXCoolCoilIndexNum).AirInNode;
-                    thisCBVAV.DXCoilOutletNode = state.dataDXCoils->DXCoil(thisCBVAV.DXCoolCoilIndexNum).AirOutNode;
-                    thisCBVAV.CondenserNodeNum = state.dataDXCoils->DXCoil(thisCBVAV.DXCoolCoilIndexNum).CondenserInletNodeNum(1);
+                    // The HXAssisted coil has already mined all of these from the child coil
+                    cbvav.childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, cbvav.CoolCoilNum);
+                    cbvav.childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, cbvav.CoolCoilNum);
+                    cbvav.childCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(state, cbvav.CoolCoilNum);
+                    // the HXAssisted coil should have already gathered all of these up properly
+                    cbvav.CoolCoilAirInletNode = HXAssistCoil::GetCoilAirInletNode(state, cbvav.childCoolCoilNum);
+                    cbvav.CoolCoilAirOutletNode = HXAssistCoil::GetCoilAirOutletNode(state, cbvav.childCoolCoilNum);
+                    cbvav.CondenserNodeNum = HXAssistCoil::GetCoilCondenserInletNode(state, cbvav.childCoolCoilNum);
                 }
             }
 
-            thisCBVAV.fanOpModeSched = Sched::GetSchedule(state, Alphas(13));
-            if (thisCBVAV.fanOpModeSched != nullptr) {
-                if (!thisCBVAV.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
+            cbvav.fanOpModeSched = Sched::GetSchedule(state, Alphas(13));
+            if (cbvav.fanOpModeSched != nullptr) {
+                if (!cbvav.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
                     Sched::ShowSevereBadMinMax(state, eoh, cAlphaFields(13), Alphas(13), Clusive::In, 0.0, Clusive::In, 1.0);
                     ShowContinueError(state, "A value of 0 represents cycling fan mode, any other value up to 1 represents constant fan mode.");
                     ErrorsFound = true;
                 }
 
                 //     Check supply air fan operating mode for cycling fan, if NOT cycling fan set AirFlowControl
-                if (!thisCBVAV.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 0.0)) { // Autodesk:Note Range is 0 to 0?
+                if (!cbvav.fanOpModeSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 0.0)) { // Autodesk:Note Range is 0 to 0?
                     //       set air flow control mode,
                     //       UseCompressorOnFlow  = operate at last cooling or heating air flow requested when compressor is off
                     //       UseCompressorOffFlow = operate at value specified by user (no input for this object type, UseCompONFlow)
                     //       AirFlowControl only valid if fan opmode = HVAC::FanOp::Continuous
-                    thisCBVAV.AirFlowControl =
-                        (thisCBVAV.MaxNoCoolHeatAirVolFlow == 0.0) ? AirFlowCtrlMode::UseCompressorOnFlow : AirFlowCtrlMode::UseCompressorOffFlow;
+                    cbvav.AirFlowControl =
+                        (cbvav.MaxNoCoolHeatAirVolFlow == 0.0) ? AirFlowCtrlMode::UseCompressorOnFlow : AirFlowCtrlMode::UseCompressorOffFlow;
                 }
 
             } else {
                 if (!lAlphaBlanks(13)) {
-                    ShowWarningError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+                    ShowWarningError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state,
                                       format("{} = {} not found. Supply air fan operating mode set to constant operation and simulation continues.",
                                              cAlphaFields(13),
                                              Alphas(13)));
                 }
-                thisCBVAV.fanOp = HVAC::FanOp::Continuous;
-                if (thisCBVAV.MaxNoCoolHeatAirVolFlow == 0.0) {
-                    thisCBVAV.AirFlowControl = AirFlowCtrlMode::UseCompressorOnFlow;
+                cbvav.fanOp = HVAC::FanOp::Continuous;
+                if (cbvav.MaxNoCoolHeatAirVolFlow == 0.0) {
+                    cbvav.AirFlowControl = AirFlowCtrlMode::UseCompressorOnFlow;
                 } else {
-                    thisCBVAV.AirFlowControl = AirFlowCtrlMode::UseCompressorOffFlow;
+                    cbvav.AirFlowControl = AirFlowCtrlMode::UseCompressorOffFlow;
                 }
             }
 
             //   Check FanVolFlow, must be >= CBVAV flow
-            if (thisCBVAV.FanVolFlow != DataSizing::AutoSize) {
-                if (thisCBVAV.FanVolFlow < thisCBVAV.MaxNoCoolHeatAirVolFlow && thisCBVAV.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize &&
-                    thisCBVAV.MaxNoCoolHeatAirVolFlow != 0.0) {
+            if (cbvav.FanVolFlow != DataSizing::AutoSize) {
+                if (cbvav.FanVolFlow < cbvav.MaxNoCoolHeatAirVolFlow && cbvav.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize &&
+                    cbvav.MaxNoCoolHeatAirVolFlow != 0.0) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in {} = {} is less than ",
                                             CurrentModuleObject,
-                                            thisCBVAV.FanVolFlow,
+                                            cbvav.FanVolFlow,
                                             cAlphaFields(11),
-                                            thisCBVAV.FanName) +
+                                            cbvav.FanName) +
                                          cNumericFields(3));
                     ShowContinueError(state, format(" {} is reset to the fan flow rate and the simulation continues.", cNumericFields(3)));
-                    ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
-                    thisCBVAV.MaxNoCoolHeatAirVolFlow = thisCBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
+                    cbvav.MaxNoCoolHeatAirVolFlow = cbvav.FanVolFlow;
                 }
             }
             //   only check that OA flow when compressor is OFF is >= SA flow when compressor is OFF when both are not autosized and
             //   that MaxNoCoolHeatAirVolFlow is /= 0 (trigger to use compressor ON flow, see AirFlowControl variable initialization above)
-            if (thisCBVAV.NoCoolHeatOutAirVolFlow > thisCBVAV.MaxNoCoolHeatAirVolFlow && thisCBVAV.NoCoolHeatOutAirVolFlow != DataSizing::AutoSize &&
-                thisCBVAV.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize && thisCBVAV.MaxNoCoolHeatAirVolFlow != 0.0) {
+            if (cbvav.NoCoolHeatOutAirVolFlow > cbvav.MaxNoCoolHeatAirVolFlow && cbvav.NoCoolHeatOutAirVolFlow != DataSizing::AutoSize &&
+                cbvav.MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize && cbvav.MaxNoCoolHeatAirVolFlow != 0.0) {
                 ShowWarningError(state, format("{}: {} cannot be greater than {}", CurrentModuleObject, cNumericFields(6), cNumericFields(3)));
                 ShowContinueError(state, format(" {} is reset to the fan flow rate and the simulation continues.", cNumericFields(6)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
-                thisCBVAV.NoCoolHeatOutAirVolFlow = thisCBVAV.FanVolFlow;
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
+                cbvav.NoCoolHeatOutAirVolFlow = cbvav.FanVolFlow;
             }
 
             std::string thisHeatCoilType = Alphas(16);
-            thisCBVAV.HeatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, thisHeatCoilType));
-            thisCBVAV.HeatCoilName = Alphas(17);
+            cbvav.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, thisHeatCoilType));
+            cbvav.HeatCoilName = Alphas(17);
 
             DXCoilErrFlag = false;
-            if (thisCBVAV.HeatCoilType == HVAC::CoilType::DXHeatingEmpirical) {
-                DXCoils::GetDXCoilIndex(state,
-                                        thisCBVAV.HeatCoilName,
-                                        thisCBVAV.DXHeatCoilIndexNum,
-                                        DXCoilErrFlag,
-                                        HVAC::coilTypeNamesUC[static_cast<int>(thisCBVAV.HeatCoilType)]);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+            if (cbvav.heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
+                cbvav.HeatCoilNum = DXCoils::GetCoilIndex(state, cbvav.HeatCoilName);
+                if (cbvav.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(17), cbvav.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.MinOATCompressor = state.dataDXCoils->DXCoil(thisCBVAV.DXHeatCoilIndexNum).MinOATCompressor;
-                    thisCBVAV.HeatingCoilInletNode = state.dataDXCoils->DXCoil(thisCBVAV.DXHeatCoilIndexNum).AirInNode;
-                    thisCBVAV.HeatingCoilOutletNode = state.dataDXCoils->DXCoil(thisCBVAV.DXHeatCoilIndexNum).AirOutNode;
-                }
-            } else if (thisCBVAV.HeatCoilType == HVAC::CoilType::HeatingAirToAirVariableSpeed) {
-                thisCBVAV.DXHeatCoilIndexNum = VariableSpeedCoils::GetCoilIndexVariableSpeed(
-                    state, HVAC::cAllCoilTypes(static_cast<int>(thisCBVAV.HeatCoilType) + 1), thisCBVAV.HeatCoilName, DXCoilErrFlag);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+                    auto const &dxCoil = state.dataDXCoils->DXCoil(cbvav.HeatCoilNum);
+                    cbvav.MinOATCompressor = dxCoil.MinOATCompressor;
+                    cbvav.HeatCoilAirInletNode = dxCoil.AirInNode;
+                    cbvav.HeatCoilAirOutletNode = dxCoil.AirOutNode;
+                }
+                
+            } else if (cbvav.heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+                cbvav.HeatCoilNum = VariableSpeedCoils::GetCoilIndex(state, cbvav.HeatCoilName);
+                if (cbvav.HeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(17), cbvav.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.MinOATCompressor = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXHeatCoilIndexNum).MinOATCompressor;
-                    thisCBVAV.HeatingCoilInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXHeatCoilIndexNum).AirInletNodeNum;
-                    thisCBVAV.HeatingCoilOutletNode = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.DXHeatCoilIndexNum).AirOutletNodeNum;
-                }
-            } else if (thisCBVAV.HeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel || thisCBVAV.HeatCoilType == HVAC::CoilType::HeatingElectric) {
-                HeatingCoils::GetCoilIndex(state, thisCBVAV.HeatCoilName, thisCBVAV.DXHeatCoilIndexNum, DXCoilErrFlag);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+                    auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(cbvav.HeatCoilNum);
+                    cbvav.MinOATCompressor = vsCoil.MinOATCompressor;
+                    cbvav.HeatCoilAirInletNode = vsCoil.AirInletNodeNum;
+                    cbvav.HeatCoilAirOutletNode = vsCoil.AirOutletNodeNum;
+                }
+            
+            } else if (cbvav.heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                       cbvav.heatCoilType == HVAC::CoilType::HeatingElectric) {
+                cbvav.HeatCoilNum = HeatingCoils::GetCoilIndex(state, cbvav.HeatCoilName);
+                if (cbvav.HeatCoilNum == 0) { 
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(17), cbvav.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.MinOATCompressor = -999.9;
-                    thisCBVAV.HeatingCoilInletNode = state.dataHeatingCoils->HeatingCoil(thisCBVAV.DXHeatCoilIndexNum).AirInletNodeNum;
-                    thisCBVAV.HeatingCoilOutletNode = state.dataHeatingCoils->HeatingCoil(thisCBVAV.DXHeatCoilIndexNum).AirOutletNodeNum;
-                }
-            } else if (thisCBVAV.HeatCoilType == HVAC::CoilType::HeatingWater) {
-                thisCBVAV.DXHeatCoilIndexNum = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", thisCBVAV.HeatCoilName, DXCoilErrFlag);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+                    auto &heatCoil = state.dataHeatingCoils->HeatingCoil(cbvav.HeatCoilNum);
+                    cbvav.MinOATCompressor = -999.9;
+                    cbvav.HeatCoilAirInletNode = heatCoil.AirInletNodeNum;
+                    cbvav.HeatCoilAirOutletNode = heatCoil.AirOutletNodeNum;
+                }
+                
+            } else if (cbvav.heatCoilType == HVAC::CoilType::HeatingWater) {
+                cbvav.HeatCoilNum = WaterCoils::GetCoilIndex(state, cbvav.HeatCoilName);
+                if (cbvav.HeatCoilNum == 0) { 
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(17), cbvav.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.CoilControlNode = state.dataWaterCoils->WaterCoil(thisCBVAV.DXHeatCoilIndexNum).WaterInletNodeNum;
-                    thisCBVAV.MaxHeatCoilFluidFlow = state.dataWaterCoils->WaterCoil(thisCBVAV.DXHeatCoilIndexNum).MaxWaterVolFlowRate;
-                    thisCBVAV.HeatingCoilInletNode = state.dataWaterCoils->WaterCoil(thisCBVAV.DXHeatCoilIndexNum).AirInletNodeNum;
-                    thisCBVAV.HeatingCoilOutletNode = state.dataWaterCoils->WaterCoil(thisCBVAV.DXHeatCoilIndexNum).AirOutletNodeNum;
-                }
-            } else if (thisCBVAV.HeatCoilType == HVAC::CoilType::HeatingSteam) {
-                thisCBVAV.HeatCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", thisCBVAV.HeatCoilName, DXCoilErrFlag);
-                if (DXCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+                    auto const &waterCoil = state.dataWaterCoils->WaterCoil(cbvav.HeatCoilNum);
+                    cbvav.HeatCoilControlNode = waterCoil.WaterInletNodeNum;
+                    cbvav.MaxHeatCoilFluidFlow = waterCoil.MaxWaterVolFlowRate;
+                    cbvav.HeatCoilAirInletNode = waterCoil.AirInletNodeNum;
+                    cbvav.HeatCoilAirOutletNode = waterCoil.AirOutletNodeNum;
+                }
+                
+            } else if (cbvav.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                cbvav.HeatCoilNum = SteamCoils::GetCoilIndex(state, cbvav.HeatCoilName);
+                if (cbvav.HeatCoilNum == 0) { 
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(17), cbvav.HeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    thisCBVAV.HeatingCoilInletNode = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).AirInletNodeNum;
-                    thisCBVAV.HeatingCoilOutletNode = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).AirOutletNodeNum;
-                    thisCBVAV.CoilControlNode = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).SteamInletNodeNum;
-                    thisCBVAV.MaxHeatCoilFluidFlow = state.dataSteamCoils->SteamCoil(thisCBVAV.HeatCoilIndex).MaxSteamVolFlowRate;
-                    Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(
-                        state, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, getUnitaryHeatCoolVAVChangeoverBypass);
-                    if (thisCBVAV.MaxHeatCoilFluidFlow > 0.0) {
-                        thisCBVAV.MaxHeatCoilFluidFlow = thisCBVAV.MaxHeatCoilFluidFlow * SteamDensity;
+                    auto const &steamCoil = state.dataSteamCoils->SteamCoil(cbvav.HeatCoilNum);
+                    cbvav.HeatCoilAirInletNode = steamCoil.AirInletNodeNum;
+                    cbvav.HeatCoilAirOutletNode = steamCoil.AirOutletNodeNum;
+                    cbvav.HeatCoilControlNode = steamCoil.SteamInletNodeNum;
+                    cbvav.MaxHeatCoilFluidFlow = steamCoil.MaxSteamVolFlowRate;
+                    if (cbvav.MaxHeatCoilFluidFlow > 0.0) {
+                        cbvav.MaxHeatCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                     }
                 }
             }
 
-            if (thisCBVAV.DXCoilOutletNode != thisCBVAV.HeatingCoilInletNode) {
+            if (cbvav.CoolCoilAirOutletNode != cbvav.HeatCoilAirInletNode) {
                 ShowSevereError(state, format("{} illegal coil placement. Cooling coil must be upstream of heating coil.", CurrentModuleObject));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ErrorsFound = true;
             }
 
-            if (thisCBVAV.fanPlace == HVAC::FanPlace::BlowThru) {
-                if (thisCBVAV.SplitterOutletAirNode != thisCBVAV.HeatingCoilOutletNode) {
-                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            if (cbvav.fanPlace == HVAC::FanPlace::BlowThru) {
+                if (cbvav.SplitterOutletAirNode != cbvav.HeatCoilAirOutletNode) {
+                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state, format("Illegal {} = {}.", cAlphaFields(6), SplitterOutletNodeName));
                     ShowContinueError(
                         state,
                         format(
                             "{} must be the same as the outlet node specified in the heating coil object = {}: {} when blow through {} is selected.",
                             cAlphaFields(6),
-                            HVAC::coilTypeNamesUC[static_cast<int>(thisCBVAV.HeatCoilType)],
-                            thisCBVAV.HeatCoilName,
+                            HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                            cbvav.HeatCoilName,
                             cAlphaFields(12)));
                     ErrorsFound = true;
                 }
-                if (thisCBVAV.MixerMixedAirNode != thisCBVAV.FanInletNodeNum) {
-                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+                if (cbvav.MixerMixedAirNode != cbvav.FanInletNodeNum) {
+                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state,
                                       format("Illegal {}. The fan inlet node name must be the same as the mixed air node specified in the {} = {} "
                                              "when blow through {} is selected.",
                                              cAlphaFields(11),
                                              cAlphaFields(9),
-                                             thisCBVAV.OAMixName,
+                                             cbvav.OAMixName,
                                              cAlphaFields(12)));
                     ErrorsFound = true;
                 }
             }
 
-            if (thisCBVAV.fanPlace == HVAC::FanPlace::DrawThru) {
-                if (thisCBVAV.MixerMixedAirNode != thisCBVAV.DXCoilInletNode) {
-                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, thisCBVAV.Name));
+            if (cbvav.fanPlace == HVAC::FanPlace::DrawThru) {
+                if (cbvav.MixerMixedAirNode != cbvav.CoolCoilAirInletNode) {
+                    ShowSevereError(state, format("{}: {}", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state,
                                       format("Illegal cooling coil placement. The cooling coil inlet node name must be the same as the mixed air "
                                              "node specified in the {} = {} when draw through {} is selected.",
                                              cAlphaFields(9),
-                                             thisCBVAV.OAMixName,
+                                             cbvav.OAMixName,
                                              cAlphaFields(12)));
                     ErrorsFound = true;
                 }
             }
 
             if (Util::SameString(Alphas(18), "CoolingPriority")) {
-                thisCBVAV.PriorityControl = PriorityCtrlMode::CoolingPriority;
+                cbvav.PriorityControl = PriorityCtrlMode::CoolingPriority;
             } else if (Util::SameString(Alphas(18), "HeatingPriority")) {
-                thisCBVAV.PriorityControl = PriorityCtrlMode::HeatingPriority;
+                cbvav.PriorityControl = PriorityCtrlMode::HeatingPriority;
             } else if (Util::SameString(Alphas(18), "ZonePriority")) {
-                thisCBVAV.PriorityControl = PriorityCtrlMode::ZonePriority;
+                cbvav.PriorityControl = PriorityCtrlMode::ZonePriority;
             } else if (Util::SameString(Alphas(18), "LoadPriority")) {
-                thisCBVAV.PriorityControl = PriorityCtrlMode::LoadPriority;
+                cbvav.PriorityControl = PriorityCtrlMode::LoadPriority;
             } else {
                 ShowSevereError(state, format("{} illegal {} = {}", CurrentModuleObject, cAlphaFields(18), Alphas(18)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                 ShowContinueError(state, "Valid choices are CoolingPriority, HeatingPriority, ZonePriority or LoadPriority.");
                 ErrorsFound = true;
             }
 
             if (Numbers(7) > 0.0) {
-                thisCBVAV.MinLATCooling = Numbers(7);
+                cbvav.MinLATCooling = Numbers(7);
             } else {
-                thisCBVAV.MinLATCooling = 10.0;
+                cbvav.MinLATCooling = 10.0;
             }
 
             if (Numbers(8) > 0.0) {
-                thisCBVAV.MaxLATHeating = Numbers(8);
+                cbvav.MaxLATHeating = Numbers(8);
             } else {
-                thisCBVAV.MaxLATHeating = 50.0;
+                cbvav.MaxLATHeating = 50.0;
             }
 
-            if (thisCBVAV.MinLATCooling > thisCBVAV.MaxLATHeating) {
+            if (cbvav.MinLATCooling > cbvav.MaxLATHeating) {
                 ShowWarningError(state, format("{}: illegal leaving air temperature specified.", CurrentModuleObject));
                 ShowContinueError(state, format("Resetting {} equal to {} and the simulation continues.", cNumericFields(7), cNumericFields(8)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
-                thisCBVAV.MinLATCooling = thisCBVAV.MaxLATHeating;
+                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
+                cbvav.MinLATCooling = cbvav.MaxLATHeating;
             }
 
             // Dehumidification control mode
             if (Util::SameString(Alphas(19), "None")) {
-                thisCBVAV.DehumidControlType = DehumidControl::None;
+                cbvav.DehumidControlType = DehumidControl::None;
             } else if (Util::SameString(Alphas(19), "")) {
-                thisCBVAV.DehumidControlType = DehumidControl::None;
+                cbvav.DehumidControlType = DehumidControl::None;
             } else if (Util::SameString(Alphas(19), "Multimode")) {
-                if (thisCBVAV.CoolCoilType == HVAC::CoilType::DXCoolingTwoStageWHumControl) {
-                    thisCBVAV.DehumidControlType = DehumidControl::Multimode;
+                if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    cbvav.DehumidControlType = DehumidControl::Multimode;
                 } else {
                     ShowWarningError(state, format("Invalid {} = {}", cAlphaFields(19), Alphas(19)));
-                    ShowContinueError(state, format("In {} \"{}\".", CurrentModuleObject, thisCBVAV.Name));
+                    ShowContinueError(state, format("In {} \"{}\".", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state, format("Valid only with {} = Coil:Cooling:DX:TwoStageWithHumidityControlMode.", cAlphaFields(14)));
                     ShowContinueError(state, format("Setting {} to \"None\" and the simulation continues.", cAlphaFields(19)));
-                    thisCBVAV.DehumidControlType = DehumidControl::None;
+                    cbvav.DehumidControlType = DehumidControl::None;
                 }
             } else if (Util::SameString(Alphas(19), "CoolReheat")) {
-                if (thisCBVAV.CoolCoilType == HVAC::CoilType::DXCoolingTwoStageWHumControl) {
-                    thisCBVAV.DehumidControlType = DehumidControl::CoolReheat;
+                if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    cbvav.DehumidControlType = DehumidControl::CoolReheat;
                 } else {
                     ShowWarningError(state, format("Invalid {} = {}", cAlphaFields(19), Alphas(19)));
-                    ShowContinueError(state, format("In {} \"{}\".", CurrentModuleObject, thisCBVAV.Name));
+                    ShowContinueError(state, format("In {} \"{}\".", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state, format("Valid only with {} = Coil:Cooling:DX:TwoStageWithHumidityControlMode.", cAlphaFields(14)));
                     ShowContinueError(state, format("Setting {} to \"None\" and the simulation continues.", cAlphaFields(19)));
-                    thisCBVAV.DehumidControlType = DehumidControl::None;
+                    cbvav.DehumidControlType = DehumidControl::None;
                 }
             } else {
                 ShowSevereError(state, format("Invalid {} ={}", cAlphaFields(19), Alphas(19)));
-                ShowContinueError(state, format("In {} \"{}\".", CurrentModuleObject, thisCBVAV.Name));
+                ShowContinueError(state, format("In {} \"{}\".", CurrentModuleObject, cbvav.Name));
             }
 
             if (NumNumbers > 8) {
-                thisCBVAV.minModeChangeTime = Numbers(9);
+                cbvav.minModeChangeTime = Numbers(9);
             }
 
             //   Initialize last mode of compressor operation
-            thisCBVAV.LastMode = HeatingMode;
+            cbvav.LastMode = HeatingMode;
 
-            if (thisCBVAV.fanType == HVAC::FanType::OnOff || thisCBVAV.fanType == HVAC::FanType::Constant) {
-                HVAC::FanType fanType2 = state.dataFans->fans(thisCBVAV.FanIndex)->type;
-                if (thisCBVAV.fanType != fanType2) {
+            if (cbvav.fanType == HVAC::FanType::OnOff || cbvav.fanType == HVAC::FanType::Constant) {
+                HVAC::FanType fanType2 = state.dataFans->fans(cbvav.FanIndex)->type;
+                if (cbvav.fanType != fanType2) {
                     ShowWarningError(
                         state,
                         format("{} has {} = {} which is inconsistent with the fan object.", CurrentModuleObject, cAlphaFields(10), Alphas(10)));
-                    ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, thisCBVAV.Name));
+                    ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, cbvav.Name));
                     ShowContinueError(state,
-                                      format(" The fan object ({}) is actually a valid fan type and the simulation continues.", thisCBVAV.FanName));
+                                      format(" The fan object ({}) is actually a valid fan type and the simulation continues.", cbvav.FanName));
                     ShowContinueError(state, " Node connections errors may result due to the inconsistent fan type.");
                 }
             }
 
             // Add fan to component sets array
-            if (thisCBVAV.fanPlace == HVAC::FanPlace::BlowThru) {
-                CompSetFanInlet = state.dataLoopNodes->NodeID(thisCBVAV.MixerMixedAirNode);
-                CompSetFanOutlet = state.dataLoopNodes->NodeID(thisCBVAV.DXCoilInletNode);
+            if (cbvav.fanPlace == HVAC::FanPlace::BlowThru) {
+                CompSetFanInlet = s_node->NodeID(cbvav.MixerMixedAirNode);
+                CompSetFanOutlet = s_node->NodeID(cbvav.CoolCoilAirInletNode);
             } else {
-                CompSetFanInlet = state.dataLoopNodes->NodeID(thisCBVAV.HeatingCoilOutletNode);
+                CompSetFanInlet = s_node->NodeID(cbvav.HeatCoilAirOutletNode);
                 CompSetFanOutlet = SplitterOutletNodeName;
             }
-            std::string CompSetCoolInlet = state.dataLoopNodes->NodeID(thisCBVAV.DXCoilInletNode);
-            std::string CompSetCoolOutlet = state.dataLoopNodes->NodeID(thisCBVAV.DXCoilOutletNode);
+            std::string CompSetCoolInlet = s_node->NodeID(cbvav.CoolCoilAirInletNode);
+            std::string CompSetCoolOutlet = s_node->NodeID(cbvav.CoolCoilAirOutletNode);
 
             // Add fan to component sets array
             BranchNodeConnections::SetUpCompSets(
-                state, thisCBVAV.UnitType, thisCBVAV.Name, Alphas(10), thisCBVAV.FanName, CompSetFanInlet, CompSetFanOutlet);
+                state, cbvav.UnitType, cbvav.Name, Alphas(10), cbvav.FanName, CompSetFanInlet, CompSetFanOutlet);
 
             // Add cooling coil to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisCBVAV.UnitType,
-                                                 thisCBVAV.Name,
-                                                 HVAC::coilTypeNamesUC[static_cast<int>(thisCBVAV.CoolCoilType)],
-                                                 thisCBVAV.DXCoolCoilName,
+                                                 cbvav.UnitType,
+                                                 cbvav.Name,
+                                                 HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                 cbvav.CoolCoilName,
                                                  CompSetCoolInlet,
                                                  CompSetCoolOutlet);
 
             // Add heating coil to component sets array
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisCBVAV.UnitType,
-                                                 thisCBVAV.Name,
-                                                 HVAC::coilTypeNamesUC[static_cast<int>(thisCBVAV.HeatCoilType)],
-                                                 thisCBVAV.HeatCoilName,
-                                                 state.dataLoopNodes->NodeID(thisCBVAV.HeatingCoilInletNode),
-                                                 state.dataLoopNodes->NodeID(thisCBVAV.HeatingCoilOutletNode));
+                                                 cbvav.UnitType,
+                                                 cbvav.Name,
+                                                 HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                 cbvav.HeatCoilName,
+                                                 s_node->NodeID(cbvav.HeatCoilAirInletNode),
+                                                 s_node->NodeID(cbvav.HeatCoilAirOutletNode));
 
             // Set up component set for OA mixer - use OA node and Mixed air node
             BranchNodeConnections::SetUpCompSets(state,
-                                                 thisCBVAV.UnitType,
-                                                 thisCBVAV.Name,
-                                                 thisCBVAV.OAMixType,
-                                                 thisCBVAV.OAMixName,
-                                                 state.dataLoopNodes->NodeID(thisCBVAV.MixerOutsideAirNode),
-                                                 state.dataLoopNodes->NodeID(thisCBVAV.MixerMixedAirNode));
+                                                 cbvav.UnitType,
+                                                 cbvav.Name,
+                                                 cbvav.OAMixType,
+                                                 cbvav.OAMixName,
+                                                 s_node->NodeID(cbvav.MixerOutsideAirNode),
+                                                 s_node->NodeID(cbvav.MixerMixedAirNode));
 
             BranchNodeConnections::TestCompSet(state,
-                                               thisCBVAV.UnitType,
-                                               thisCBVAV.Name,
-                                               state.dataLoopNodes->NodeID(thisCBVAV.AirInNode),
-                                               state.dataLoopNodes->NodeID(thisCBVAV.AirOutNode),
+                                               cbvav.UnitType,
+                                               cbvav.Name,
+                                               s_node->NodeID(cbvav.AirInNode),
+                                               s_node->NodeID(cbvav.AirOutNode),
                                                "Air Nodes");
 
             //   Find air loop associated with CBVAV system
@@ -1079,66 +1035,66 @@ namespace HVACUnitaryBypassVAV {
                     for (int CompNum = 1; CompNum <= state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).TotalComponents;
                          ++CompNum) {
                         if (!Util::SameString(state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).Name,
-                                              thisCBVAV.Name) ||
+                                              cbvav.Name) ||
                             !Util::SameString(state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).TypeOf,
-                                              thisCBVAV.UnitType))
+                                              cbvav.UnitType))
                             continue;
-                        thisCBVAV.AirLoopNumber = AirLoopNum;
+                        cbvav.AirLoopNumber = AirLoopNum;
                         //         Should EXIT here or do other checking?
                         break;
                     }
                 }
             }
 
-            if (thisCBVAV.AirLoopNumber > 0) {
-                thisCBVAV.NumControlledZones = state.dataAirLoop->AirToZoneNodeInfo(thisCBVAV.AirLoopNumber).NumZonesCooled;
-                thisCBVAV.ControlledZoneNum.allocate(thisCBVAV.NumControlledZones);
-                thisCBVAV.ControlledZoneNodeNum.allocate(thisCBVAV.NumControlledZones);
-                thisCBVAV.CBVAVBoxOutletNode.allocate(thisCBVAV.NumControlledZones);
-                thisCBVAV.ZoneSequenceCoolingNum.allocate(thisCBVAV.NumControlledZones);
-                thisCBVAV.ZoneSequenceHeatingNum.allocate(thisCBVAV.NumControlledZones);
+            if (cbvav.AirLoopNumber > 0) {
+                cbvav.NumControlledZones = state.dataAirLoop->AirToZoneNodeInfo(cbvav.AirLoopNumber).NumZonesCooled;
+                cbvav.ControlledZoneNum.allocate(cbvav.NumControlledZones);
+                cbvav.ControlledZoneNodeNum.allocate(cbvav.NumControlledZones);
+                cbvav.CBVAVBoxOutletNode.allocate(cbvav.NumControlledZones);
+                cbvav.ZoneSequenceCoolingNum.allocate(cbvav.NumControlledZones);
+                cbvav.ZoneSequenceHeatingNum.allocate(cbvav.NumControlledZones);
 
-                thisCBVAV.ControlledZoneNum = 0;
-                for (int AirLoopZoneNum = 1; AirLoopZoneNum <= state.dataAirLoop->AirToZoneNodeInfo(thisCBVAV.AirLoopNumber).NumZonesCooled;
+                cbvav.ControlledZoneNum = 0;
+                for (int AirLoopZoneNum = 1; AirLoopZoneNum <= state.dataAirLoop->AirToZoneNodeInfo(cbvav.AirLoopNumber).NumZonesCooled;
                      ++AirLoopZoneNum) {
-                    thisCBVAV.ControlledZoneNum(AirLoopZoneNum) =
-                        state.dataAirLoop->AirToZoneNodeInfo(thisCBVAV.AirLoopNumber).CoolCtrlZoneNums(AirLoopZoneNum);
-                    if (thisCBVAV.ControlledZoneNum(AirLoopZoneNum) > 0) {
-                        thisCBVAV.ControlledZoneNodeNum(AirLoopZoneNum) =
-                            state.dataZoneEquip->ZoneEquipConfig(thisCBVAV.ControlledZoneNum(AirLoopZoneNum)).ZoneNode;
-                        thisCBVAV.CBVAVBoxOutletNode(AirLoopZoneNum) =
-                            state.dataAirLoop->AirToZoneNodeInfo(thisCBVAV.AirLoopNumber).CoolZoneInletNodes(AirLoopZoneNum);
+                    cbvav.ControlledZoneNum(AirLoopZoneNum) =
+                        state.dataAirLoop->AirToZoneNodeInfo(cbvav.AirLoopNumber).CoolCtrlZoneNums(AirLoopZoneNum);
+                    if (cbvav.ControlledZoneNum(AirLoopZoneNum) > 0) {
+                        cbvav.ControlledZoneNodeNum(AirLoopZoneNum) =
+                            state.dataZoneEquip->ZoneEquipConfig(cbvav.ControlledZoneNum(AirLoopZoneNum)).ZoneNode;
+                        cbvav.CBVAVBoxOutletNode(AirLoopZoneNum) =
+                            state.dataAirLoop->AirToZoneNodeInfo(cbvav.AirLoopNumber).CoolZoneInletNodes(AirLoopZoneNum);
                         // check for thermostat in controlled zone
                         bool FoundTstatZone = false;
                         for (int TstatZoneNum = 1; TstatZoneNum <= state.dataZoneCtrls->NumTempControlledZones; ++TstatZoneNum) {
-                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != thisCBVAV.ControlledZoneNum(AirLoopZoneNum))
+                            if (state.dataZoneCtrls->TempControlledZone(TstatZoneNum).ActualZoneNum != cbvav.ControlledZoneNum(AirLoopZoneNum))
                                 continue;
                             FoundTstatZone = true;
                         }
                         if (!FoundTstatZone) {
-                            ShowWarningError(state, format("{} \"{}\"", CurrentModuleObject, thisCBVAV.Name));
+                            ShowWarningError(state, format("{} \"{}\"", CurrentModuleObject, cbvav.Name));
                             ShowContinueError(state,
                                               format("Thermostat not found in zone = {} and the simulation continues.",
-                                                     state.dataZoneEquip->ZoneEquipConfig(thisCBVAV.ControlledZoneNum(AirLoopZoneNum)).ZoneName));
+                                                     state.dataZoneEquip->ZoneEquipConfig(cbvav.ControlledZoneNum(AirLoopZoneNum)).ZoneName));
                             ShowContinueError(state, "This zone will not be controlled to a temperature setpoint.");
                         }
-                        int zoneNum = thisCBVAV.ControlledZoneNum(AirLoopZoneNum);
-                        int zoneInlet = thisCBVAV.CBVAVBoxOutletNode(AirLoopZoneNum);
+                        int zoneNum = cbvav.ControlledZoneNum(AirLoopZoneNum);
+                        int zoneInlet = cbvav.CBVAVBoxOutletNode(AirLoopZoneNum);
                         // setup zone equipment sequence information based on finding matching air terminal
                         if (state.dataZoneEquip->ZoneEquipConfig(zoneNum).EquipListIndex > 0) {
                             int coolingPriority = 0;
                             int heatingPriority = 0;
                             state.dataZoneEquip->ZoneEquipList(state.dataZoneEquip->ZoneEquipConfig(zoneNum).EquipListIndex)
                                 .getPrioritiesForInletNode(state, zoneInlet, coolingPriority, heatingPriority);
-                            thisCBVAV.ZoneSequenceCoolingNum(AirLoopZoneNum) = coolingPriority;
-                            thisCBVAV.ZoneSequenceHeatingNum(AirLoopZoneNum) = heatingPriority;
+                            cbvav.ZoneSequenceCoolingNum(AirLoopZoneNum) = coolingPriority;
+                            cbvav.ZoneSequenceHeatingNum(AirLoopZoneNum) = heatingPriority;
                         }
-                        if (thisCBVAV.ZoneSequenceCoolingNum(AirLoopZoneNum) == 0 || thisCBVAV.ZoneSequenceHeatingNum(AirLoopZoneNum) == 0) {
+                        if (cbvav.ZoneSequenceCoolingNum(AirLoopZoneNum) == 0 || cbvav.ZoneSequenceHeatingNum(AirLoopZoneNum) == 0) {
                             ShowSevereError(
                                 state,
                                 format("AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass, \"{}\": Airloop air terminal in the zone equipment list for "
                                        "zone = {} not found or is not allowed Zone Equipment Cooling or Heating Sequence = 0.",
-                                       thisCBVAV.Name,
+                                       cbvav.Name,
                                        state.dataZoneEquip->ZoneEquipConfig(zoneNum).ZoneName));
                             ErrorsFound = true;
                         }
@@ -1158,140 +1114,140 @@ namespace HVACUnitaryBypassVAV {
 
         for (int CBVAVNum = 1; CBVAVNum <= NumCBVAV; ++CBVAVNum) {
             // Setup Report variables
-            auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+            auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
             SetupOutputVariable(state,
                                 "Unitary System Total Heating Rate",
                                 Constant::Units::W,
-                                thisCBVAV.TotHeatEnergyRate,
+                                cbvav.TotHeatEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Total Heating Energy",
                                 Constant::Units::J,
-                                thisCBVAV.TotHeatEnergy,
+                                cbvav.TotHeatEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Total Cooling Rate",
                                 Constant::Units::W,
-                                thisCBVAV.TotCoolEnergyRate,
+                                cbvav.TotCoolEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Total Cooling Energy",
                                 Constant::Units::J,
-                                thisCBVAV.TotCoolEnergy,
+                                cbvav.TotCoolEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Sensible Heating Rate",
                                 Constant::Units::W,
-                                thisCBVAV.SensHeatEnergyRate,
+                                cbvav.SensHeatEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Sensible Heating Energy",
                                 Constant::Units::J,
-                                thisCBVAV.SensHeatEnergy,
+                                cbvav.SensHeatEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Sensible Cooling Rate",
                                 Constant::Units::W,
-                                thisCBVAV.SensCoolEnergyRate,
+                                cbvav.SensCoolEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Sensible Cooling Energy",
                                 Constant::Units::J,
-                                thisCBVAV.SensCoolEnergy,
+                                cbvav.SensCoolEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Latent Heating Rate",
                                 Constant::Units::W,
-                                thisCBVAV.LatHeatEnergyRate,
+                                cbvav.LatHeatEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Latent Heating Energy",
                                 Constant::Units::J,
-                                thisCBVAV.LatHeatEnergy,
+                                cbvav.LatHeatEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Latent Cooling Rate",
                                 Constant::Units::W,
-                                thisCBVAV.LatCoolEnergyRate,
+                                cbvav.LatCoolEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Latent Cooling Energy",
                                 Constant::Units::J,
-                                thisCBVAV.LatCoolEnergy,
+                                cbvav.LatCoolEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Electricity Rate",
                                 Constant::Units::W,
-                                thisCBVAV.ElecPower,
+                                cbvav.ElecPower,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Electricity Energy",
                                 Constant::Units::J,
-                                thisCBVAV.ElecConsumption,
+                                cbvav.ElecConsumption,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Fan Part Load Ratio",
                                 Constant::Units::None,
-                                thisCBVAV.FanPartLoadRatio,
+                                cbvav.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Compressor Part Load Ratio",
                                 Constant::Units::None,
-                                thisCBVAV.CompPartLoadRatio,
+                                cbvav.CompPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Bypass Air Mass Flow Rate",
                                 Constant::Units::kg_s,
-                                thisCBVAV.BypassMassFlowRate,
+                                cbvav.BypassMassFlowRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Air Outlet Setpoint Temperature",
                                 Constant::Units::C,
-                                thisCBVAV.OutletTempSetPoint,
+                                cbvav.OutletTempSetPoint,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
             SetupOutputVariable(state,
                                 "Unitary System Operating Mode Index",
                                 Constant::Units::None,
-                                thisCBVAV.HeatCoolMode,
+                                cbvav.HeatCoolMode,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                thisCBVAV.Name);
+                                cbvav.Name);
         }
     }
 
@@ -1329,12 +1285,11 @@ namespace HVACUnitaryBypassVAV {
         bool ErrorFlag;              // local error flag returned from data mining
         Real64 mdot;                 // heating coil fluid mass flow rate, kg/s
 
-        auto &cBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &s_node = state.dataLoopNodes;
+        
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
         int NumCBVAV = state.dataHVACUnitaryBypassVAV->NumCBVAV;
 
-        int InNode = cBVAV.AirInNode;
-        int OutNode = cBVAV.AirOutNode;
-
         // Do the one time initializations
         if (state.dataHVACUnitaryBypassVAV->MyOneTimeFlag) {
 
@@ -1353,52 +1308,52 @@ namespace HVACUnitaryBypassVAV {
         }
 
         if (state.dataHVACUnitaryBypassVAV->MyPlantScanFlag(CBVAVNum) && allocated(state.dataPlnt->PlantLoop)) {
-            if ((cBVAV.HeatCoilType == HVAC::CoilType::HeatingWater) || (cBVAV.HeatCoilType == HVAC::CoilType::HeatingSteam)) {
+            if ((cbvav.heatCoilType == HVAC::CoilType::HeatingWater) ||
+                (cbvav.heatCoilType == HVAC::CoilType::HeatingSteam)) {
                 bool ErrorsFound = false; // Set to true if errors in input, fatal at end of routine
-                if (cBVAV.HeatCoilType == HVAC::CoilType::HeatingWater) {
+                if (cbvav.heatCoilType == HVAC::CoilType::HeatingWater) {
 
                     ErrorFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(
-                        state, cBVAV.HeatCoilName, DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, cBVAV.plantLoc, ErrorFlag, _, _, _, _, _);
+                        state, cbvav.HeatCoilName, DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, cbvav.HeatCoilPlantLoc, ErrorFlag, _, _, _, _, _);
                     if (ErrorFlag) {
                         ShowFatalError(state, "InitCBVAV: Program terminated for previous conditions.");
                     }
 
-                    cBVAV.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", cBVAV.HeatCoilName, ErrorsFound);
+                    cbvav.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, cbvav.HeatCoilNum);
 
-                    if (cBVAV.MaxHeatCoilFluidFlow > 0.0) {
+                    if (cbvav.MaxHeatCoilFluidFlow > 0.0) {
                         Real64 FluidDensity =
-                            state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                        cBVAV.MaxHeatCoilFluidFlow =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", cBVAV.HeatCoilName, ErrorsFound) * FluidDensity;
+                            state.dataPlnt->PlantLoop(cbvav.HeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
+                        cbvav.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, cbvav.HeatCoilNum) * FluidDensity;
                     }
 
-                } else if (cBVAV.HeatCoilType == HVAC::CoilType::HeatingSteam) {
+                } else if (cbvav.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
                     ErrorFlag = false;
                     PlantUtilities::ScanPlantLoopsForObject(
-                        state, cBVAV.HeatCoilName, DataPlant::PlantEquipmentType::CoilSteamAirHeating, cBVAV.plantLoc, ErrorFlag, _, _, _, _, _);
+                        state, cbvav.HeatCoilName, DataPlant::PlantEquipmentType::CoilSteamAirHeating, cbvav.HeatCoilPlantLoc, ErrorFlag, _, _, _, _, _);
 
                     if (ErrorFlag) {
                         ShowFatalError(state, "InitCBVAV: Program terminated for previous conditions.");
                     }
 
-                    cBVAV.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, cBVAV.HeatCoilIndex, ErrorsFound);
+                    cbvav.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, cbvav.HeatCoilNum);
 
-                    if (cBVAV.MaxHeatCoilFluidFlow > 0.0) {
+                    if (cbvav.MaxHeatCoilFluidFlow > 0.0) {
                         // Why is TempSteamIn a state variable of the entire module?
                         Real64 FluidDensity =
                             Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, RoutineName);
 
-                        cBVAV.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, cBVAV.HeatCoilIndex, ErrorsFound) * FluidDensity;
+                        cbvav.MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, cbvav.HeatCoilNum) * FluidDensity;
                     }
                 }
 
                 if (ErrorsFound) {
-                    ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cBVAV.Name));
+                    ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cbvav.Name));
                 }
                 // fill outlet node for heating coil
-                cBVAV.CoilOutletNode = DataPlant::CompData::getPlantComponent(state, cBVAV.plantLoc).NodeNumOut;
+                cbvav.HeatCoilFluidOutletNode = DataPlant::CompData::getPlantComponent(state, cbvav.HeatCoilPlantLoc).NodeNumOut;
                 state.dataHVACUnitaryBypassVAV->MyPlantScanFlag(CBVAVNum) = false;
 
             } else { // CBVAV is not connected to plant
@@ -1411,13 +1366,13 @@ namespace HVACUnitaryBypassVAV {
         if (!state.dataGlobal->SysSizingCalc && state.dataHVACUnitaryBypassVAV->MySizeFlag(CBVAVNum)) {
             SizeCBVAV(state, CBVAVNum);
             // Pass the fan cycling schedule index up to the air loop. Set the air loop unitary system flag.
-            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).cycFanSched = cBVAV.fanOpModeSched;
+            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).cycFanSched = cbvav.fanOpModeSched;
             //   Set UnitarySys flag to FALSE and let the heating coil autosize independently of the cooling coil
             state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySys = false;
-            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = cBVAV.fanOp;
+            state.dataAirLoop->AirLoopControlInfo(AirLoopNum).fanOp = cbvav.fanOp;
             // check for set point manager on outlet node of CBVAV
-            cBVAV.OutNodeSPMIndex = SetPointManager::GetSetPointManagerIndexByNode(state,
-                                                                                   OutNode,
+            cbvav.OutNodeSPMIndex = SetPointManager::GetSetPointManagerIndexByNode(state,
+                                                                                   cbvav.AirOutNode,
                                                                                    HVAC::CtrlVarType::Temp,
                                                                                    SetPointManager::SPMType::MixedAir,
                                                                                    true); // isRefNode
@@ -1426,69 +1381,61 @@ namespace HVACUnitaryBypassVAV {
 
         // Do the Begin Environment initializations
         if (state.dataGlobal->BeginEnvrnFlag && state.dataHVACUnitaryBypassVAV->MyEnvrnFlag(CBVAVNum)) {
-            int MixerOutsideAirNode = cBVAV.MixerOutsideAirNode;
             Real64 RhoAir = state.dataEnvrn->StdRhoAir;
             // set the mass flow rates from the input volume flow rates
-            cBVAV.MaxCoolAirMassFlow = RhoAir * cBVAV.MaxCoolAirVolFlow;
-            cBVAV.CoolOutAirMassFlow = RhoAir * cBVAV.CoolOutAirVolFlow;
-            cBVAV.MaxHeatAirMassFlow = RhoAir * cBVAV.MaxHeatAirVolFlow;
-            cBVAV.HeatOutAirMassFlow = RhoAir * cBVAV.HeatOutAirVolFlow;
-            cBVAV.MaxNoCoolHeatAirMassFlow = RhoAir * cBVAV.MaxNoCoolHeatAirVolFlow;
-            cBVAV.NoCoolHeatOutAirMassFlow = RhoAir * cBVAV.NoCoolHeatOutAirVolFlow;
+            cbvav.MaxCoolAirMassFlow = RhoAir * cbvav.MaxCoolAirVolFlow;
+            cbvav.CoolOutAirMassFlow = RhoAir * cbvav.CoolOutAirVolFlow;
+            cbvav.MaxHeatAirMassFlow = RhoAir * cbvav.MaxHeatAirVolFlow;
+            cbvav.HeatOutAirMassFlow = RhoAir * cbvav.HeatOutAirVolFlow;
+            cbvav.MaxNoCoolHeatAirMassFlow = RhoAir * cbvav.MaxNoCoolHeatAirVolFlow;
+            cbvav.NoCoolHeatOutAirMassFlow = RhoAir * cbvav.NoCoolHeatOutAirVolFlow;
             // set the node max and min mass flow rates
-            state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMax = max(cBVAV.CoolOutAirMassFlow, cBVAV.HeatOutAirMassFlow);
-            state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMaxAvail = max(cBVAV.CoolOutAirMassFlow, cBVAV.HeatOutAirMassFlow);
-            state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMin = 0.0;
-            state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMinAvail = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMax = max(cBVAV.MaxCoolAirMassFlow, cBVAV.MaxHeatAirMassFlow);
-            state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail = max(cBVAV.MaxCoolAirMassFlow, cBVAV.MaxHeatAirMassFlow);
-            state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMinAvail = 0.0;
-            state.dataLoopNodes->Node(OutNode).Temp = state.dataLoopNodes->Node(InNode).Temp;
-            state.dataLoopNodes->Node(OutNode).HumRat = state.dataLoopNodes->Node(InNode).HumRat;
-            state.dataLoopNodes->Node(OutNode).Enthalpy = state.dataLoopNodes->Node(InNode).Enthalpy;
-            state.dataLoopNodes->Node(cBVAV.MixerReliefAirNode) = state.dataLoopNodes->Node(MixerOutsideAirNode);
+            s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMax = max(cbvav.CoolOutAirMassFlow, cbvav.HeatOutAirMassFlow);
+            s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMaxAvail = max(cbvav.CoolOutAirMassFlow, cbvav.HeatOutAirMassFlow);
+            s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMin = 0.0;
+            s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMinAvail = 0.0;
+            s_node->Node(cbvav.AirInNode).MassFlowRateMax = max(cbvav.MaxCoolAirMassFlow, cbvav.MaxHeatAirMassFlow);
+            s_node->Node(cbvav.AirInNode).MassFlowRateMaxAvail = max(cbvav.MaxCoolAirMassFlow, cbvav.MaxHeatAirMassFlow);
+            s_node->Node(cbvav.AirInNode).MassFlowRateMin = 0.0;
+            s_node->Node(cbvav.AirInNode).MassFlowRateMinAvail = 0.0;
+            s_node->Node(cbvav.AirOutNode).Temp = s_node->Node(cbvav.AirInNode).Temp;
+            s_node->Node(cbvav.AirOutNode).HumRat = s_node->Node(cbvav.AirInNode).HumRat;
+            s_node->Node(cbvav.AirOutNode).Enthalpy = s_node->Node(cbvav.AirInNode).Enthalpy;
+            s_node->Node(cbvav.MixerReliefAirNode) = s_node->Node(cbvav.MixerOutsideAirNode);
             state.dataHVACUnitaryBypassVAV->MyEnvrnFlag(CBVAVNum) = false;
-            cBVAV.LastMode = HeatingMode;
-            cBVAV.changeOverTimer = -1.0;
+            cbvav.LastMode = HeatingMode;
+            cbvav.changeOverTimer = -1.0;
             //   set fluid-side hardware limits
-            if (cBVAV.CoilControlNode > 0) {
+            if (cbvav.HeatCoilControlNode > 0) {
                 //    If water coil max water flow rate is autosized, simulate once in order to mine max water flow rate
-                if (cBVAV.MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
-                    if (cBVAV.HeatCoilType == HVAC::CoilType::HeatingWater) {
-                        WaterCoils::SimulateWaterCoilComponents(state, cBVAV.HeatCoilName, FirstHVACIteration, cBVAV.HeatCoilIndex);
-                        ErrorFlag = false;
-                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", cBVAV.HeatCoilName, ErrorFlag);
-                        if (ErrorFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cBVAV.Name));
-                        }
+                if (cbvav.MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
+                    if (cbvav.heatCoilType == HVAC::CoilType::HeatingWater) {
+                        WaterCoils::SimulateWaterCoilComponents(state, cbvav.HeatCoilNum, FirstHVACIteration);
+                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, cbvav.HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                             Real64 FluidDensity =
-                                state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                            cBVAV.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity;
+                                state.dataPlnt->PlantLoop(cbvav.HeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
+                            cbvav.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity;
                         }
-                    }
-                    if (cBVAV.HeatCoilType == HVAC::CoilType::HeatingSteam) {
+
+                    } else if (cbvav.heatCoilType == HVAC::CoilType::HeatingSteam) {
                         SteamCoils::SimulateSteamCoilComponents(state,
-                                                                cBVAV.HeatCoilName,
+                                                                cbvav.HeatCoilNum,
                                                                 FirstHVACIteration,
-                                                                cBVAV.HeatCoilIndex,
                                                                 1.0,
                                                                 QCoilActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
                         ErrorFlag = false;
-                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, cBVAV.HeatCoilIndex, ErrorFlag);
+                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, cbvav.HeatCoilNum);
                         if (ErrorFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cBVAV.Name));
+                            ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cbvav.Name));
                         }
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            Real64 FluidDensity =
-                                Fluid::GetSteam(state)->getSatDensity(state, state.dataHVACUnitaryBypassVAV->TempSteamIn, 1.0, RoutineName);
-                            cBVAV.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity;
+                            cbvav.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                         }
                     }
                 } // end of IF(cBVAV%MaxHeatCoilFluidFlow .EQ. DataSizing::AutoSize)THEN
 
-                PlantUtilities::InitComponentNodes(state, 0.0, cBVAV.MaxHeatCoilFluidFlow, cBVAV.CoilControlNode, cBVAV.CoilOutletNode);
+                PlantUtilities::InitComponentNodes(state, 0.0, cbvav.MaxHeatCoilFluidFlow, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode);
 
             } // end of IF(cBVAV%CoilControlNode .GT. 0)THEN
         }     // end one time inits
@@ -1498,179 +1445,179 @@ namespace HVACUnitaryBypassVAV {
         }
 
         // IF CBVAV system was not autosized and the fan is autosized, check that fan volumetric flow rate is greater than CBVAV flow rates
-        if (cBVAV.CheckFanFlow) {
+        if (cbvav.CheckFanFlow) {
 
-            if (!state.dataGlobal->DoingSizing && cBVAV.FanVolFlow != DataSizing::AutoSize) {
+            if (!state.dataGlobal->DoingSizing && cbvav.FanVolFlow != DataSizing::AutoSize) {
                 std::string CurrentModuleObject = "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass";
                 //     Check fan versus system supply air flow rates
-                if (cBVAV.FanVolFlow < cBVAV.MaxCoolAirVolFlow) {
+                if (cbvav.FanVolFlow < cbvav.MaxCoolAirVolFlow) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the maximum CBVAV system air flow rate when "
                                             "cooling is required ({:.7T}).",
                                             CurrentModuleObject,
-                                            cBVAV.FanVolFlow,
-                                            cBVAV.FanName,
-                                            cBVAV.MaxCoolAirVolFlow));
+                                            cbvav.FanVolFlow,
+                                            cbvav.FanName,
+                                            cbvav.MaxCoolAirVolFlow));
                     ShowContinueError(
                         state, " The CBVAV system flow rate when cooling is required is reset to the fan flow rate and the simulation continues.");
-                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cBVAV.Name));
-                    cBVAV.MaxCoolAirVolFlow = cBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cbvav.Name));
+                    cbvav.MaxCoolAirVolFlow = cbvav.FanVolFlow;
                 }
-                if (cBVAV.FanVolFlow < cBVAV.MaxHeatAirVolFlow) {
+                if (cbvav.FanVolFlow < cbvav.MaxHeatAirVolFlow) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the maximum CBVAV system air flow rate when "
                                             "heating is required ({:.7T}).",
                                             CurrentModuleObject,
-                                            cBVAV.FanVolFlow,
-                                            cBVAV.FanName,
-                                            cBVAV.MaxHeatAirVolFlow));
+                                            cbvav.FanVolFlow,
+                                            cbvav.FanName,
+                                            cbvav.MaxHeatAirVolFlow));
                     ShowContinueError(
                         state, " The CBVAV system flow rate when heating is required is reset to the fan flow rate and the simulation continues.");
-                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cBVAV.Name));
-                    cBVAV.MaxHeatAirVolFlow = cBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cbvav.Name));
+                    cbvav.MaxHeatAirVolFlow = cbvav.FanVolFlow;
                 }
-                if (cBVAV.FanVolFlow < cBVAV.MaxNoCoolHeatAirVolFlow && cBVAV.MaxNoCoolHeatAirVolFlow != 0.0) {
+                if (cbvav.FanVolFlow < cbvav.MaxNoCoolHeatAirVolFlow && cbvav.MaxNoCoolHeatAirVolFlow != 0.0) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the maximum CBVAV system air flow rate when "
                                             "no heating or cooling is needed ({:.7T}).",
                                             CurrentModuleObject,
-                                            cBVAV.FanVolFlow,
-                                            cBVAV.FanName,
-                                            cBVAV.MaxNoCoolHeatAirVolFlow));
+                                            cbvav.FanVolFlow,
+                                            cbvav.FanName,
+                                            cbvav.MaxNoCoolHeatAirVolFlow));
                     ShowContinueError(state,
                                       " The CBVAV system flow rate when no heating or cooling is needed is reset to the fan flow rate and the "
                                       "simulation continues.");
-                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cBVAV.Name));
-                    cBVAV.MaxNoCoolHeatAirVolFlow = cBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cbvav.Name));
+                    cbvav.MaxNoCoolHeatAirVolFlow = cbvav.FanVolFlow;
                 }
                 //     Check fan versus outdoor air flow rates
-                if (cBVAV.FanVolFlow < cBVAV.CoolOutAirVolFlow) {
+                if (cbvav.FanVolFlow < cbvav.CoolOutAirVolFlow) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the maximum CBVAV outdoor air flow rate when "
                                             "cooling is required ({:.7T}).",
                                             CurrentModuleObject,
-                                            cBVAV.FanVolFlow,
-                                            cBVAV.FanName,
-                                            cBVAV.CoolOutAirVolFlow));
+                                            cbvav.FanVolFlow,
+                                            cbvav.FanName,
+                                            cbvav.CoolOutAirVolFlow));
                     ShowContinueError(
                         state, " The CBVAV outdoor flow rate when cooling is required is reset to the fan flow rate and the simulation continues.");
-                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cBVAV.Name));
-                    cBVAV.CoolOutAirVolFlow = cBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cbvav.Name));
+                    cbvav.CoolOutAirVolFlow = cbvav.FanVolFlow;
                 }
-                if (cBVAV.FanVolFlow < cBVAV.HeatOutAirVolFlow) {
+                if (cbvav.FanVolFlow < cbvav.HeatOutAirVolFlow) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the maximum CBVAV outdoor air flow rate when "
                                             "heating is required ({:.7T}).",
                                             CurrentModuleObject,
-                                            cBVAV.FanVolFlow,
-                                            cBVAV.FanName,
-                                            cBVAV.HeatOutAirVolFlow));
+                                            cbvav.FanVolFlow,
+                                            cbvav.FanName,
+                                            cbvav.HeatOutAirVolFlow));
                     ShowContinueError(
                         state, " The CBVAV outdoor flow rate when heating is required is reset to the fan flow rate and the simulation continues.");
-                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cBVAV.Name));
-                    cBVAV.HeatOutAirVolFlow = cBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cbvav.Name));
+                    cbvav.HeatOutAirVolFlow = cbvav.FanVolFlow;
                 }
-                if (cBVAV.FanVolFlow < cBVAV.NoCoolHeatOutAirVolFlow) {
+                if (cbvav.FanVolFlow < cbvav.NoCoolHeatOutAirVolFlow) {
                     ShowWarningError(state,
                                      format("{} - air flow rate = {:.7T} in fan object {} is less than the maximum CBVAV outdoor air flow rate when "
                                             "no heating or cooling is needed ({:.7T}).",
                                             CurrentModuleObject,
-                                            cBVAV.FanVolFlow,
-                                            cBVAV.FanName,
-                                            cBVAV.NoCoolHeatOutAirVolFlow));
+                                            cbvav.FanVolFlow,
+                                            cbvav.FanName,
+                                            cbvav.NoCoolHeatOutAirVolFlow));
                     ShowContinueError(state,
                                       " The CBVAV outdoor flow rate when no heating or cooling is needed is reset to the fan flow rate and the "
                                       "simulation continues.");
-                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cBVAV.Name));
-                    cBVAV.NoCoolHeatOutAirVolFlow = cBVAV.FanVolFlow;
+                    ShowContinueError(state, format(" Occurs in Changeover-bypass VAV system = {}", cbvav.Name));
+                    cbvav.NoCoolHeatOutAirVolFlow = cbvav.FanVolFlow;
                 }
-                int MixerOutsideAirNode = cBVAV.MixerOutsideAirNode;
+
                 Real64 RhoAir = state.dataEnvrn->StdRhoAir;
                 // set the mass flow rates from the reset volume flow rates
-                cBVAV.MaxCoolAirMassFlow = RhoAir * cBVAV.MaxCoolAirVolFlow;
-                cBVAV.CoolOutAirMassFlow = RhoAir * cBVAV.CoolOutAirVolFlow;
-                cBVAV.MaxHeatAirMassFlow = RhoAir * cBVAV.MaxHeatAirVolFlow;
-                cBVAV.HeatOutAirMassFlow = RhoAir * cBVAV.HeatOutAirVolFlow;
-                cBVAV.MaxNoCoolHeatAirMassFlow = RhoAir * cBVAV.MaxNoCoolHeatAirVolFlow;
-                cBVAV.NoCoolHeatOutAirMassFlow = RhoAir * cBVAV.NoCoolHeatOutAirVolFlow;
+                cbvav.MaxCoolAirMassFlow = RhoAir * cbvav.MaxCoolAirVolFlow;
+                cbvav.CoolOutAirMassFlow = RhoAir * cbvav.CoolOutAirVolFlow;
+                cbvav.MaxHeatAirMassFlow = RhoAir * cbvav.MaxHeatAirVolFlow;
+                cbvav.HeatOutAirMassFlow = RhoAir * cbvav.HeatOutAirVolFlow;
+                cbvav.MaxNoCoolHeatAirMassFlow = RhoAir * cbvav.MaxNoCoolHeatAirVolFlow;
+                cbvav.NoCoolHeatOutAirMassFlow = RhoAir * cbvav.NoCoolHeatOutAirVolFlow;
                 // set the node max and min mass flow rates based on reset volume flow rates
-                state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMax = max(cBVAV.CoolOutAirMassFlow, cBVAV.HeatOutAirMassFlow);
-                state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMaxAvail = max(cBVAV.CoolOutAirMassFlow, cBVAV.HeatOutAirMassFlow);
-                state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMin = 0.0;
-                state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRateMinAvail = 0.0;
-                state.dataLoopNodes->Node(InNode).MassFlowRateMax = max(cBVAV.MaxCoolAirMassFlow, cBVAV.MaxHeatAirMassFlow);
-                state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail = max(cBVAV.MaxCoolAirMassFlow, cBVAV.MaxHeatAirMassFlow);
-                state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
-                state.dataLoopNodes->Node(InNode).MassFlowRateMinAvail = 0.0;
-                state.dataLoopNodes->Node(OutNode).Temp = state.dataLoopNodes->Node(InNode).Temp;
-                state.dataLoopNodes->Node(OutNode).HumRat = state.dataLoopNodes->Node(InNode).HumRat;
-                state.dataLoopNodes->Node(OutNode).Enthalpy = state.dataLoopNodes->Node(InNode).Enthalpy;
-                state.dataLoopNodes->Node(cBVAV.MixerReliefAirNode) = state.dataLoopNodes->Node(MixerOutsideAirNode);
-                cBVAV.CheckFanFlow = false;
-                if (cBVAV.FanVolFlow > 0.0) {
-                    cBVAV.HeatingSpeedRatio = cBVAV.MaxHeatAirVolFlow / cBVAV.FanVolFlow;
-                    cBVAV.CoolingSpeedRatio = cBVAV.MaxCoolAirVolFlow / cBVAV.FanVolFlow;
-                    cBVAV.NoHeatCoolSpeedRatio = cBVAV.MaxNoCoolHeatAirVolFlow / cBVAV.FanVolFlow;
+                s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMax = max(cbvav.CoolOutAirMassFlow, cbvav.HeatOutAirMassFlow);
+                s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMaxAvail = max(cbvav.CoolOutAirMassFlow, cbvav.HeatOutAirMassFlow);
+                s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMin = 0.0;
+                s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRateMinAvail = 0.0;
+                s_node->Node(cbvav.AirInNode).MassFlowRateMax = max(cbvav.MaxCoolAirMassFlow, cbvav.MaxHeatAirMassFlow);
+                s_node->Node(cbvav.AirInNode).MassFlowRateMaxAvail = max(cbvav.MaxCoolAirMassFlow, cbvav.MaxHeatAirMassFlow);
+                s_node->Node(cbvav.AirInNode).MassFlowRateMin = 0.0;
+                s_node->Node(cbvav.AirInNode).MassFlowRateMinAvail = 0.0;
+                s_node->Node(cbvav.AirOutNode).Temp = s_node->Node(cbvav.AirInNode).Temp;
+                s_node->Node(cbvav.AirOutNode).HumRat = s_node->Node(cbvav.AirInNode).HumRat;
+                s_node->Node(cbvav.AirOutNode).Enthalpy = s_node->Node(cbvav.AirInNode).Enthalpy;
+                s_node->Node(cbvav.MixerReliefAirNode) = s_node->Node(cbvav.MixerOutsideAirNode);
+                cbvav.CheckFanFlow = false;
+                if (cbvav.FanVolFlow > 0.0) {
+                    cbvav.HeatingSpeedRatio = cbvav.MaxHeatAirVolFlow / cbvav.FanVolFlow;
+                    cbvav.CoolingSpeedRatio = cbvav.MaxCoolAirVolFlow / cbvav.FanVolFlow;
+                    cbvav.NoHeatCoolSpeedRatio = cbvav.MaxNoCoolHeatAirVolFlow / cbvav.FanVolFlow;
                 }
             }
         }
 
-        if (cBVAV.fanOpModeSched != nullptr) {
-            cBVAV.fanOp = (cBVAV.fanOpModeSched->getCurrentVal() == 0.0) ? HVAC::FanOp::Cycling : HVAC::FanOp::Continuous;
+        if (cbvav.fanOpModeSched != nullptr) {
+            cbvav.fanOp = (cbvav.fanOpModeSched->getCurrentVal() == 0.0) ? HVAC::FanOp::Cycling : HVAC::FanOp::Continuous;
         }
 
         // Returns load only for zones requesting cooling (heating). If in deadband, Qzoneload = 0.
-        if (FirstHVACIteration) cBVAV.modeChanged = false;
+        if (FirstHVACIteration) cbvav.modeChanged = false;
         GetZoneLoads(state, CBVAVNum);
 
-        OutsideAirMultiplier = (cBVAV.outAirSched != nullptr) ? cBVAV.outAirSched->getCurrentVal() : 1.0;
+        OutsideAirMultiplier = (cbvav.outAirSched != nullptr) ? cbvav.outAirSched->getCurrentVal() : 1.0;
 
         // Set the inlet node mass flow rate
-        if (cBVAV.fanOp == HVAC::FanOp::Continuous) {
+        if (cbvav.fanOp == HVAC::FanOp::Continuous) {
             // constant fan mode
-            if (cBVAV.HeatCoolMode == HeatingMode) {
-                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cBVAV.MaxHeatAirMassFlow;
-                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cBVAV.HeatingSpeedRatio;
-                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cBVAV.HeatOutAirMassFlow * OutsideAirMultiplier;
-            } else if (cBVAV.HeatCoolMode == CoolingMode) {
-                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cBVAV.MaxCoolAirMassFlow;
-                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cBVAV.CoolingSpeedRatio;
-                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cBVAV.CoolOutAirMassFlow * OutsideAirMultiplier;
+            if (cbvav.HeatCoolMode == HeatingMode) {
+                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cbvav.MaxHeatAirMassFlow;
+                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cbvav.HeatingSpeedRatio;
+                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cbvav.HeatOutAirMassFlow * OutsideAirMultiplier;
+            } else if (cbvav.HeatCoolMode == CoolingMode) {
+                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cbvav.MaxCoolAirMassFlow;
+                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cbvav.CoolingSpeedRatio;
+                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cbvav.CoolOutAirMassFlow * OutsideAirMultiplier;
             } else {
-                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cBVAV.MaxNoCoolHeatAirMassFlow;
-                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cBVAV.NoHeatCoolSpeedRatio;
-                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cBVAV.NoCoolHeatOutAirMassFlow * OutsideAirMultiplier;
+                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cbvav.MaxNoCoolHeatAirMassFlow;
+                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cbvav.NoHeatCoolSpeedRatio;
+                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cbvav.NoCoolHeatOutAirMassFlow * OutsideAirMultiplier;
             }
 
-            if (cBVAV.AirFlowControl == AirFlowCtrlMode::UseCompressorOnFlow) {
-                if (cBVAV.LastMode == HeatingMode) {
-                    state.dataHVACUnitaryBypassVAV->CompOffMassFlow = cBVAV.MaxHeatAirMassFlow;
-                    state.dataHVACUnitaryBypassVAV->CompOffFlowRatio = cBVAV.HeatingSpeedRatio;
-                    state.dataHVACUnitaryBypassVAV->OACompOffMassFlow = cBVAV.HeatOutAirMassFlow * OutsideAirMultiplier;
+            if (cbvav.AirFlowControl == AirFlowCtrlMode::UseCompressorOnFlow) {
+                if (cbvav.LastMode == HeatingMode) {
+                    state.dataHVACUnitaryBypassVAV->CompOffMassFlow = cbvav.MaxHeatAirMassFlow;
+                    state.dataHVACUnitaryBypassVAV->CompOffFlowRatio = cbvav.HeatingSpeedRatio;
+                    state.dataHVACUnitaryBypassVAV->OACompOffMassFlow = cbvav.HeatOutAirMassFlow * OutsideAirMultiplier;
                 } else {
-                    state.dataHVACUnitaryBypassVAV->CompOffMassFlow = cBVAV.MaxCoolAirMassFlow;
-                    state.dataHVACUnitaryBypassVAV->CompOffFlowRatio = cBVAV.CoolingSpeedRatio;
-                    state.dataHVACUnitaryBypassVAV->OACompOffMassFlow = cBVAV.CoolOutAirMassFlow * OutsideAirMultiplier;
+                    state.dataHVACUnitaryBypassVAV->CompOffMassFlow = cbvav.MaxCoolAirMassFlow;
+                    state.dataHVACUnitaryBypassVAV->CompOffFlowRatio = cbvav.CoolingSpeedRatio;
+                    state.dataHVACUnitaryBypassVAV->OACompOffMassFlow = cbvav.CoolOutAirMassFlow * OutsideAirMultiplier;
                 }
             } else {
-                state.dataHVACUnitaryBypassVAV->CompOffMassFlow = cBVAV.MaxNoCoolHeatAirMassFlow;
-                state.dataHVACUnitaryBypassVAV->CompOffFlowRatio = cBVAV.NoHeatCoolSpeedRatio;
-                state.dataHVACUnitaryBypassVAV->OACompOffMassFlow = cBVAV.NoCoolHeatOutAirMassFlow * OutsideAirMultiplier;
+                state.dataHVACUnitaryBypassVAV->CompOffMassFlow = cbvav.MaxNoCoolHeatAirMassFlow;
+                state.dataHVACUnitaryBypassVAV->CompOffFlowRatio = cbvav.NoHeatCoolSpeedRatio;
+                state.dataHVACUnitaryBypassVAV->OACompOffMassFlow = cbvav.NoCoolHeatOutAirMassFlow * OutsideAirMultiplier;
             }
         } else {
             // cycling fan mode
-            if (cBVAV.HeatCoolMode == HeatingMode) {
-                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cBVAV.MaxHeatAirMassFlow;
-                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cBVAV.HeatingSpeedRatio;
-                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cBVAV.HeatOutAirMassFlow * OutsideAirMultiplier;
-            } else if (cBVAV.HeatCoolMode == CoolingMode) {
-                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cBVAV.MaxCoolAirMassFlow;
-                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cBVAV.CoolingSpeedRatio;
-                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cBVAV.CoolOutAirMassFlow * OutsideAirMultiplier;
+            if (cbvav.HeatCoolMode == HeatingMode) {
+                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cbvav.MaxHeatAirMassFlow;
+                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cbvav.HeatingSpeedRatio;
+                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cbvav.HeatOutAirMassFlow * OutsideAirMultiplier;
+            } else if (cbvav.HeatCoolMode == CoolingMode) {
+                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cbvav.MaxCoolAirMassFlow;
+                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cbvav.CoolingSpeedRatio;
+                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cbvav.CoolOutAirMassFlow * OutsideAirMultiplier;
             } else {
-                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cBVAV.MaxCoolAirMassFlow;
-                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cBVAV.CoolingSpeedRatio;
-                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cBVAV.CoolOutAirMassFlow * OutsideAirMultiplier;
+                state.dataHVACUnitaryBypassVAV->CompOnMassFlow = cbvav.MaxCoolAirMassFlow;
+                state.dataHVACUnitaryBypassVAV->CompOnFlowRatio = cbvav.CoolingSpeedRatio;
+                state.dataHVACUnitaryBypassVAV->OACompOnMassFlow = cbvav.CoolOutAirMassFlow * OutsideAirMultiplier;
             }
             state.dataHVACUnitaryBypassVAV->CompOffMassFlow = 0.0;
             state.dataHVACUnitaryBypassVAV->CompOffFlowRatio = 0.0;
@@ -1678,74 +1625,74 @@ namespace HVACUnitaryBypassVAV {
         }
 
         // Check for correct control node at outlet of unit
-        if (cBVAV.HumRatMaxCheck) {
-            if (cBVAV.DehumidControlType != DehumidControl::None) {
-                if (state.dataLoopNodes->Node(OutNode).HumRatMax == DataLoopNode::SensedNodeFlagValue) {
+        if (cbvav.HumRatMaxCheck) {
+            if (cbvav.DehumidControlType != DehumidControl::None) {
+                if (s_node->Node(cbvav.AirOutNode).HumRatMax == DataLoopNode::SensedNodeFlagValue) {
                     if (!state.dataGlobal->AnyEnergyManagementSystemInModel) {
-                        ShowWarningError(state, format("Unitary System:VAV:ChangeOverBypass = {}", cBVAV.Name));
+                        ShowWarningError(state, format("Unitary System:VAV:ChangeOverBypass = {}", cbvav.Name));
                         ShowContinueError(state,
                                           "Use SetpointManager:SingleZone:Humidity:Maximum to place a humidity setpoint at the air outlet node of "
                                           "the unitary system.");
                         ShowContinueError(state, "Setting Dehumidification Control Type to None and simulation continues.");
-                        cBVAV.DehumidControlType = DehumidControl::None;
+                        cbvav.DehumidControlType = DehumidControl::None;
                     } else {
                         // need call to EMS to check node
                         bool EMSSetPointCheck = false;
-                        EMSManager::CheckIfNodeSetPointManagedByEMS(state, OutNode, HVAC::CtrlVarType::MaxHumRat, EMSSetPointCheck);
-                        state.dataLoopNodes->NodeSetpointCheck(OutNode).needsSetpointChecking = false;
+                        EMSManager::CheckIfNodeSetPointManagedByEMS(state, cbvav.AirOutNode, HVAC::CtrlVarType::MaxHumRat, EMSSetPointCheck);
+                        s_node->NodeSetpointCheck(cbvav.AirOutNode).needsSetpointChecking = false;
                         if (EMSSetPointCheck) {
                             // There is no plugin anyways, so we now we have a bad condition.
-                            ShowWarningError(state, format("Unitary System:VAV:ChangeOverBypass = {}", cBVAV.Name));
+                            ShowWarningError(state, format("Unitary System:VAV:ChangeOverBypass = {}", cbvav.Name));
                             ShowContinueError(state,
                                               "Use SetpointManager:SingleZone:Humidity:Maximum to place a humidity setpoint at the air outlet node "
                                               "of the unitary system.");
                             ShowContinueError(
                                 state, "Or use an EMS Actuator to place a maximum humidity setpoint at the air outlet node of the unitary system.");
                             ShowContinueError(state, "Setting Dehumidification Control Type to None and simulation continues.");
-                            cBVAV.DehumidControlType = DehumidControl::None;
+                            cbvav.DehumidControlType = DehumidControl::None;
                         }
                     }
                 }
-                cBVAV.HumRatMaxCheck = false;
+                cbvav.HumRatMaxCheck = false;
             } else {
-                cBVAV.HumRatMaxCheck = false;
+                cbvav.HumRatMaxCheck = false;
             }
         }
 
         // Set the inlet node mass flow rate
-        if (cBVAV.availSched->getCurrentVal() > 0.0 && state.dataHVACUnitaryBypassVAV->CompOnMassFlow != 0.0) {
+        if (cbvav.availSched->getCurrentVal() > 0.0 && state.dataHVACUnitaryBypassVAV->CompOnMassFlow != 0.0) {
             OnOffAirFlowRatio = 1.0;
             if (FirstHVACIteration) {
-                state.dataLoopNodes->Node(cBVAV.AirInNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
-                state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
-                state.dataLoopNodes->Node(cBVAV.MixerOutsideAirNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->OACompOnMassFlow;
-                state.dataLoopNodes->Node(cBVAV.MixerReliefAirNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->OACompOnMassFlow;
+                s_node->Node(cbvav.AirInNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
+                s_node->Node(cbvav.MixerInletAirNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
+                s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->OACompOnMassFlow;
+                s_node->Node(cbvav.MixerReliefAirNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->OACompOnMassFlow;
                 state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction = 0.0;
                 state.dataHVACUnitaryBypassVAV->PartLoadFrac = 0.0;
             } else {
-                if (cBVAV.HeatCoolMode != 0) {
+                if (cbvav.HeatCoolMode != 0) {
                     state.dataHVACUnitaryBypassVAV->PartLoadFrac = 1.0;
                 } else {
                     state.dataHVACUnitaryBypassVAV->PartLoadFrac = 0.0;
                 }
-                if (cBVAV.fanOp == HVAC::FanOp::Cycling) {
+                if (cbvav.fanOp == HVAC::FanOp::Cycling) {
                     state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction = 0.0;
                 } else {
-                    if (cBVAV.PlenumMixerInletAirNode == 0) {
+                    if (cbvav.PlenumMixerInletAirNode == 0) {
                         state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction = max(
-                            0.0, 1.0 - (state.dataLoopNodes->Node(cBVAV.AirInNode).MassFlowRate / state.dataHVACUnitaryBypassVAV->CompOnMassFlow));
+                            0.0, 1.0 - (s_node->Node(cbvav.AirInNode).MassFlowRate / state.dataHVACUnitaryBypassVAV->CompOnMassFlow));
                     }
                 }
             }
         } else {
             state.dataHVACUnitaryBypassVAV->PartLoadFrac = 0.0;
-            state.dataLoopNodes->Node(cBVAV.AirInNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(cBVAV.AirOutNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(cBVAV.AirOutNode).MassFlowRateMaxAvail = 0.0;
+            s_node->Node(cbvav.AirInNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.AirOutNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.AirOutNode).MassFlowRateMaxAvail = 0.0;
 
-            state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(cBVAV.MixerOutsideAirNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(cBVAV.MixerReliefAirNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.MixerInletAirNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.MixerReliefAirNode).MassFlowRate = 0.0;
 
             OnOffAirFlowRatio = 1.0;
             state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction = 0.0;
@@ -1754,63 +1701,60 @@ namespace HVACUnitaryBypassVAV {
         CalcCBVAV(state, CBVAVNum, FirstHVACIteration, state.dataHVACUnitaryBypassVAV->PartLoadFrac, QSensUnitOut, OnOffAirFlowRatio, HXUnitOn);
 
         // If unit is scheduled OFF, setpoint is equal to inlet node temperature.
-        if (cBVAV.availSched->getCurrentVal() == 0.0) {
-            cBVAV.OutletTempSetPoint = state.dataLoopNodes->Node(InNode).Temp;
+        if (cbvav.availSched->getCurrentVal() == 0.0) {
+            cbvav.OutletTempSetPoint = s_node->Node(cbvav.AirInNode).Temp;
             return;
         }
 
         SetAverageAirFlow(state, CBVAVNum, OnOffAirFlowRatio);
 
-        if (FirstHVACIteration) cBVAV.OutletTempSetPoint = CalcSetPointTempTarget(state, CBVAVNum);
+        if (FirstHVACIteration) cbvav.OutletTempSetPoint = CalcSetPointTempTarget(state, CBVAVNum);
 
         // The setpoint is used to control the DX coils at their respective outlet nodes (not the unit outlet), correct
         // for fan heat for draw thru units only (fan heat is included at the outlet of each coil when blowthru is used)
-        cBVAV.CoilTempSetPoint = cBVAV.OutletTempSetPoint;
-        if (cBVAV.fanPlace == HVAC::FanPlace::DrawThru) {
-            cBVAV.CoilTempSetPoint -= (state.dataLoopNodes->Node(cBVAV.AirOutNode).Temp - state.dataLoopNodes->Node(cBVAV.FanInletNodeNum).Temp);
+        cbvav.CoilTempSetPoint = cbvav.OutletTempSetPoint;
+        if (cbvav.fanPlace == HVAC::FanPlace::DrawThru) {
+            cbvav.CoilTempSetPoint -= (s_node->Node(cbvav.AirOutNode).Temp - s_node->Node(cbvav.FanInletNodeNum).Temp);
         }
 
         if (FirstHVACIteration) {
-            if (cBVAV.HeatCoilType == HVAC::CoilType::HeatingWater) {
-                WaterCoils::SimulateWaterCoilComponents(state, cBVAV.HeatCoilName, FirstHVACIteration, cBVAV.HeatCoilIndex);
+            if (cbvav.heatCoilType == HVAC::CoilType::HeatingWater) {
+                WaterCoils::SimulateWaterCoilComponents(state, cbvav.HeatCoilNum, FirstHVACIteration);
 
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
-                mdot = cBVAV.MaxHeatCoilFluidFlow;
-                PlantUtilities::SetComponentFlowRate(state, mdot, cBVAV.CoilControlNode, cBVAV.CoilOutletNode, cBVAV.plantLoc);
+                s_node->Node(cbvav.HeatCoilAirInletNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
+                mdot = cbvav.MaxHeatCoilFluidFlow;
+                PlantUtilities::SetComponentFlowRate(state, mdot, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode, cbvav.HeatCoilPlantLoc);
 
                 //     simulate water coil to find operating capacity
-                WaterCoils::SimulateWaterCoilComponents(state, cBVAV.HeatCoilName, FirstHVACIteration, cBVAV.HeatCoilIndex, QCoilActual);
-                cBVAV.DesignSuppHeatingCapacity = QCoilActual;
-
-            } // from IF(MSHeatPump(MSHeatPumpNum)%SuppHeatCoilType == HVAC::Coil_HeatingWater) THEN
+                WaterCoils::SimulateWaterCoilComponents(state, cbvav.HeatCoilNum, FirstHVACIteration, QCoilActual);
+                cbvav.DesignSuppHeatingCapacity = QCoilActual;
 
-            if (cBVAV.HeatCoilType == HVAC::CoilType::HeatingSteam) {
+            } else if (cbvav.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
                 //     set air-side and steam-side mass flow rates
-                state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
-                mdot = cBVAV.MaxHeatCoilFluidFlow;
-                PlantUtilities::SetComponentFlowRate(state, mdot, cBVAV.CoilControlNode, cBVAV.CoilOutletNode, cBVAV.plantLoc);
+                s_node->Node(cbvav.HeatCoilAirInletNode).MassFlowRate = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
+                mdot = cbvav.MaxHeatCoilFluidFlow;
+                PlantUtilities::SetComponentFlowRate(state, mdot, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode, cbvav.HeatCoilPlantLoc);
 
                 //     simulate steam coil to find operating capacity
                 SteamCoils::SimulateSteamCoilComponents(state,
-                                                        cBVAV.HeatCoilName,
+                                                        cbvav.HeatCoilNum,
                                                         FirstHVACIteration,
-                                                        cBVAV.HeatCoilIndex,
                                                         1.0,
                                                         QCoilActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                cBVAV.DesignSuppHeatingCapacity = QCoilActual;
+                cbvav.DesignSuppHeatingCapacity = QCoilActual;
 
             } // from IF(cBVAV%HeatCoilType == HVAC::Coil_HeatingSteam) THEN
         }     // from IF( FirstHVACIteration ) THEN
 
-        if ((cBVAV.HeatCoolMode == 0 && cBVAV.fanOp == HVAC::FanOp::Cycling) || state.dataHVACUnitaryBypassVAV->CompOnMassFlow == 0.0) {
+        if ((cbvav.HeatCoolMode == 0 && cbvav.fanOp == HVAC::FanOp::Cycling) || state.dataHVACUnitaryBypassVAV->CompOnMassFlow == 0.0) {
             state.dataHVACUnitaryBypassVAV->PartLoadFrac = 0.0;
-            state.dataLoopNodes->Node(cBVAV.AirInNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(cBVAV.AirOutNode).MassFlowRateMaxAvail = 0.0;
-            state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(cBVAV.MixerOutsideAirNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(cBVAV.MixerReliefAirNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.AirInNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.AirOutNode).MassFlowRateMaxAvail = 0.0;
+            s_node->Node(cbvav.MixerInletAirNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRate = 0.0;
+            s_node->Node(cbvav.MixerReliefAirNode).MassFlowRate = 0.0;
         }
     }
 
@@ -1830,67 +1774,67 @@ namespace HVACUnitaryBypassVAV {
         int curSysNum = state.dataSize->CurSysNum;
         int curOASysNum = state.dataSize->CurOASysNum;
 
-        auto &cBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
         if (curSysNum > 0 && curOASysNum == 0) {
-            state.dataAirSystemsData->PrimaryAirSystems(curSysNum).supFanNum = cBVAV.FanIndex;
-            state.dataAirSystemsData->PrimaryAirSystems(curSysNum).supFanType = cBVAV.fanType;
-            state.dataAirSystemsData->PrimaryAirSystems(curSysNum).supFanPlace = cBVAV.fanPlace;
+            state.dataAirSystemsData->PrimaryAirSystems(curSysNum).supFanNum = cbvav.FanIndex;
+            state.dataAirSystemsData->PrimaryAirSystems(curSysNum).supFanType = cbvav.fanType;
+            state.dataAirSystemsData->PrimaryAirSystems(curSysNum).supFanPlace = cbvav.fanPlace;
         }
 
-        if (cBVAV.MaxCoolAirVolFlow == DataSizing::AutoSize) {
+        if (cbvav.MaxCoolAirVolFlow == DataSizing::AutoSize) {
 
             if (curSysNum > 0) {
 
-                CheckSysSizing(state, cBVAV.UnitType, cBVAV.Name);
-                cBVAV.MaxCoolAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesMainVolFlow;
-                if (cBVAV.FanVolFlow < cBVAV.MaxCoolAirVolFlow && cBVAV.FanVolFlow != DataSizing::AutoSize) {
-                    cBVAV.MaxCoolAirVolFlow = cBVAV.FanVolFlow;
-                    ShowWarningError(state, format("{} \"{}\"", cBVAV.UnitType, cBVAV.Name));
+                CheckSysSizing(state, cbvav.UnitType, cbvav.Name);
+                cbvav.MaxCoolAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesMainVolFlow;
+                if (cbvav.FanVolFlow < cbvav.MaxCoolAirVolFlow && cbvav.FanVolFlow != DataSizing::AutoSize) {
+                    cbvav.MaxCoolAirVolFlow = cbvav.FanVolFlow;
+                    ShowWarningError(state, format("{} \"{}\"", cbvav.UnitType, cbvav.Name));
                     ShowContinueError(state,
                                       "The CBVAV system supply air fan air flow rate is less than the autosized value for the maximum air flow rate "
                                       "in cooling mode. Consider autosizing the fan for this simulation.");
                     ShowContinueError(
                         state, "The maximum air flow rate in cooling mode is reset to the supply air fan flow rate and the simulation continues.");
                 }
-                if (cBVAV.MaxCoolAirVolFlow < HVAC::SmallAirVolFlow) {
-                    cBVAV.MaxCoolAirVolFlow = 0.0;
+                if (cbvav.MaxCoolAirVolFlow < HVAC::SmallAirVolFlow) {
+                    cbvav.MaxCoolAirVolFlow = 0.0;
                 }
-                BaseSizer::reportSizerOutput(state, cBVAV.UnitType, cBVAV.Name, "maximum cooling air flow rate [m3/s]", cBVAV.MaxCoolAirVolFlow);
+                BaseSizer::reportSizerOutput(state, cbvav.UnitType, cbvav.Name, "maximum cooling air flow rate [m3/s]", cbvav.MaxCoolAirVolFlow);
             }
         }
 
-        if (cBVAV.MaxHeatAirVolFlow == DataSizing::AutoSize) {
+        if (cbvav.MaxHeatAirVolFlow == DataSizing::AutoSize) {
 
             if (curSysNum > 0) {
 
-                CheckSysSizing(state, cBVAV.UnitType, cBVAV.Name);
-                cBVAV.MaxHeatAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesMainVolFlow;
-                if (cBVAV.FanVolFlow < cBVAV.MaxHeatAirVolFlow && cBVAV.FanVolFlow != DataSizing::AutoSize) {
-                    cBVAV.MaxHeatAirVolFlow = cBVAV.FanVolFlow;
-                    ShowWarningError(state, format("{} \"{}\"", cBVAV.UnitType, cBVAV.Name));
+                CheckSysSizing(state, cbvav.UnitType, cbvav.Name);
+                cbvav.MaxHeatAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesMainVolFlow;
+                if (cbvav.FanVolFlow < cbvav.MaxHeatAirVolFlow && cbvav.FanVolFlow != DataSizing::AutoSize) {
+                    cbvav.MaxHeatAirVolFlow = cbvav.FanVolFlow;
+                    ShowWarningError(state, format("{} \"{}\"", cbvav.UnitType, cbvav.Name));
                     ShowContinueError(state,
                                       "The CBVAV system supply air fan air flow rate is less than the autosized value for the maximum air flow rate "
                                       "in heating mode. Consider autosizing the fan for this simulation.");
                     ShowContinueError(
                         state, "The maximum air flow rate in heating mode is reset to the supply air fan flow rate and the simulation continues.");
                 }
-                if (cBVAV.MaxHeatAirVolFlow < HVAC::SmallAirVolFlow) {
-                    cBVAV.MaxHeatAirVolFlow = 0.0;
+                if (cbvav.MaxHeatAirVolFlow < HVAC::SmallAirVolFlow) {
+                    cbvav.MaxHeatAirVolFlow = 0.0;
                 }
-                BaseSizer::reportSizerOutput(state, cBVAV.UnitType, cBVAV.Name, "maximum heating air flow rate [m3/s]", cBVAV.MaxHeatAirVolFlow);
+                BaseSizer::reportSizerOutput(state, cbvav.UnitType, cbvav.Name, "maximum heating air flow rate [m3/s]", cbvav.MaxHeatAirVolFlow);
             }
         }
 
-        if (cBVAV.MaxNoCoolHeatAirVolFlow == DataSizing::AutoSize) {
+        if (cbvav.MaxNoCoolHeatAirVolFlow == DataSizing::AutoSize) {
 
             if (curSysNum > 0) {
 
-                CheckSysSizing(state, cBVAV.UnitType, cBVAV.Name);
-                cBVAV.MaxNoCoolHeatAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesMainVolFlow;
-                if (cBVAV.FanVolFlow < cBVAV.MaxNoCoolHeatAirVolFlow && cBVAV.FanVolFlow != DataSizing::AutoSize) {
-                    cBVAV.MaxNoCoolHeatAirVolFlow = cBVAV.FanVolFlow;
-                    ShowWarningError(state, format("{} \"{}\"", cBVAV.UnitType, cBVAV.Name));
+                CheckSysSizing(state, cbvav.UnitType, cbvav.Name);
+                cbvav.MaxNoCoolHeatAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesMainVolFlow;
+                if (cbvav.FanVolFlow < cbvav.MaxNoCoolHeatAirVolFlow && cbvav.FanVolFlow != DataSizing::AutoSize) {
+                    cbvav.MaxNoCoolHeatAirVolFlow = cbvav.FanVolFlow;
+                    ShowWarningError(state, format("{} \"{}\"", cbvav.UnitType, cbvav.Name));
                     ShowContinueError(state,
                                       "The CBVAV system supply air fan air flow rate is less than the autosized value for the maximum air flow rate "
                                       "when no heating or cooling is needed. Consider autosizing the fan for this simulation.");
@@ -1898,68 +1842,68 @@ namespace HVACUnitaryBypassVAV {
                                       "The maximum air flow rate when no heating or cooling is needed is reset to the supply air fan flow rate and "
                                       "the simulation continues.");
                 }
-                if (cBVAV.MaxNoCoolHeatAirVolFlow < HVAC::SmallAirVolFlow) {
-                    cBVAV.MaxNoCoolHeatAirVolFlow = 0.0;
+                if (cbvav.MaxNoCoolHeatAirVolFlow < HVAC::SmallAirVolFlow) {
+                    cbvav.MaxNoCoolHeatAirVolFlow = 0.0;
                 }
 
                 BaseSizer::reportSizerOutput(
-                    state, cBVAV.UnitType, cBVAV.Name, "maximum air flow rate when compressor/coil is off [m3/s]", cBVAV.MaxNoCoolHeatAirVolFlow);
+                    state, cbvav.UnitType, cbvav.Name, "maximum air flow rate when compressor/coil is off [m3/s]", cbvav.MaxNoCoolHeatAirVolFlow);
             }
         }
 
-        if (cBVAV.CoolOutAirVolFlow == DataSizing::AutoSize) {
+        if (cbvav.CoolOutAirVolFlow == DataSizing::AutoSize) {
 
             if (curSysNum > 0) {
 
-                CheckSysSizing(state, cBVAV.UnitType, cBVAV.Name);
-                cBVAV.CoolOutAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesOutAirVolFlow;
-                if (cBVAV.FanVolFlow < cBVAV.CoolOutAirVolFlow && cBVAV.FanVolFlow != DataSizing::AutoSize) {
-                    cBVAV.CoolOutAirVolFlow = cBVAV.FanVolFlow;
-                    ShowWarningError(state, format("{} \"{}\"", cBVAV.UnitType, cBVAV.Name));
+                CheckSysSizing(state, cbvav.UnitType, cbvav.Name);
+                cbvav.CoolOutAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesOutAirVolFlow;
+                if (cbvav.FanVolFlow < cbvav.CoolOutAirVolFlow && cbvav.FanVolFlow != DataSizing::AutoSize) {
+                    cbvav.CoolOutAirVolFlow = cbvav.FanVolFlow;
+                    ShowWarningError(state, format("{} \"{}\"", cbvav.UnitType, cbvav.Name));
                     ShowContinueError(state,
                                       "The CBVAV system supply air fan air flow rate is less than the autosized value for the outdoor air flow rate "
                                       "in cooling mode. Consider autosizing the fan for this simulation.");
                     ShowContinueError(
                         state, "The outdoor air flow rate in cooling mode is reset to the supply air fan flow rate and the simulation continues.");
                 }
-                if (cBVAV.CoolOutAirVolFlow < HVAC::SmallAirVolFlow) {
-                    cBVAV.CoolOutAirVolFlow = 0.0;
+                if (cbvav.CoolOutAirVolFlow < HVAC::SmallAirVolFlow) {
+                    cbvav.CoolOutAirVolFlow = 0.0;
                 }
                 BaseSizer::reportSizerOutput(
-                    state, cBVAV.UnitType, cBVAV.Name, "maximum outside air flow rate in cooling [m3/s]", cBVAV.CoolOutAirVolFlow);
+                    state, cbvav.UnitType, cbvav.Name, "maximum outside air flow rate in cooling [m3/s]", cbvav.CoolOutAirVolFlow);
             }
         }
 
-        if (cBVAV.HeatOutAirVolFlow == DataSizing::AutoSize) {
+        if (cbvav.HeatOutAirVolFlow == DataSizing::AutoSize) {
 
             if (curSysNum > 0) {
 
-                CheckSysSizing(state, cBVAV.UnitType, cBVAV.Name);
-                cBVAV.HeatOutAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesOutAirVolFlow;
-                if (cBVAV.FanVolFlow < cBVAV.HeatOutAirVolFlow && cBVAV.FanVolFlow != DataSizing::AutoSize) {
-                    cBVAV.HeatOutAirVolFlow = cBVAV.FanVolFlow;
+                CheckSysSizing(state, cbvav.UnitType, cbvav.Name);
+                cbvav.HeatOutAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesOutAirVolFlow;
+                if (cbvav.FanVolFlow < cbvav.HeatOutAirVolFlow && cbvav.FanVolFlow != DataSizing::AutoSize) {
+                    cbvav.HeatOutAirVolFlow = cbvav.FanVolFlow;
                     ShowContinueError(state,
                                       "The CBVAV system supply air fan air flow rate is less than the autosized value for the outdoor air flow rate "
                                       "in heating mode. Consider autosizing the fan for this simulation.");
                     ShowContinueError(
                         state, "The outdoor air flow rate in heating mode is reset to the supply air fan flow rate and the simulation continues.");
                 }
-                if (cBVAV.HeatOutAirVolFlow < HVAC::SmallAirVolFlow) {
-                    cBVAV.HeatOutAirVolFlow = 0.0;
+                if (cbvav.HeatOutAirVolFlow < HVAC::SmallAirVolFlow) {
+                    cbvav.HeatOutAirVolFlow = 0.0;
                 }
                 BaseSizer::reportSizerOutput(
-                    state, cBVAV.UnitType, cBVAV.Name, "maximum outdoor air flow rate in heating [m3/s]", cBVAV.CoolOutAirVolFlow);
+                    state, cbvav.UnitType, cbvav.Name, "maximum outdoor air flow rate in heating [m3/s]", cbvav.CoolOutAirVolFlow);
             }
         }
 
-        if (cBVAV.NoCoolHeatOutAirVolFlow == DataSizing::AutoSize) {
+        if (cbvav.NoCoolHeatOutAirVolFlow == DataSizing::AutoSize) {
 
             if (curSysNum > 0) {
 
-                CheckSysSizing(state, cBVAV.UnitType, cBVAV.Name);
-                cBVAV.NoCoolHeatOutAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesOutAirVolFlow;
-                if (cBVAV.FanVolFlow < cBVAV.NoCoolHeatOutAirVolFlow && cBVAV.FanVolFlow != DataSizing::AutoSize) {
-                    cBVAV.NoCoolHeatOutAirVolFlow = cBVAV.FanVolFlow;
+                CheckSysSizing(state, cbvav.UnitType, cbvav.Name);
+                cbvav.NoCoolHeatOutAirVolFlow = state.dataSize->FinalSysSizing(curSysNum).DesOutAirVolFlow;
+                if (cbvav.FanVolFlow < cbvav.NoCoolHeatOutAirVolFlow && cbvav.FanVolFlow != DataSizing::AutoSize) {
+                    cbvav.NoCoolHeatOutAirVolFlow = cbvav.FanVolFlow;
                     ShowContinueError(state,
                                       "The CBVAV system supply air fan air flow rate is less than the autosized value for the outdoor air flow rate "
                                       "when no heating or cooling is needed. Consider autosizing the fan for this simulation.");
@@ -1967,11 +1911,11 @@ namespace HVACUnitaryBypassVAV {
                                       "The outdoor air flow rate when no heating or cooling is needed is reset to the supply air fan flow rate and "
                                       "the simulation continues.");
                 }
-                if (cBVAV.NoCoolHeatOutAirVolFlow < HVAC::SmallAirVolFlow) {
-                    cBVAV.NoCoolHeatOutAirVolFlow = 0.0;
+                if (cbvav.NoCoolHeatOutAirVolFlow < HVAC::SmallAirVolFlow) {
+                    cbvav.NoCoolHeatOutAirVolFlow = 0.0;
                 }
                 BaseSizer::reportSizerOutput(
-                    state, cBVAV.UnitType, cBVAV.Name, "maximum outdoor air flow rate when compressor is off [m3/s]", cBVAV.NoCoolHeatOutAirVolFlow);
+                    state, cbvav.UnitType, cbvav.Name, "maximum outdoor air flow rate when compressor is off [m3/s]", cbvav.NoCoolHeatOutAirVolFlow);
             }
         }
     }
@@ -1999,15 +1943,16 @@ namespace HVACUnitaryBypassVAV {
         Real64 FullOutput = 0; // Unit full output when compressor is operating [W]
         PartLoadFrac = 0.0;
 
-        auto &cBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &s_node = state.dataLoopNodes;
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
-        if (cBVAV.availSched->getCurrentVal() == 0.0) return;
+        if (cbvav.availSched->getCurrentVal() == 0.0) return;
 
         // Get operating result
         PartLoadFrac = 1.0;
         CalcCBVAV(state, CBVAVNum, FirstHVACIteration, PartLoadFrac, FullOutput, OnOffAirFlowRatio, HXUnitOn);
 
-        if ((state.dataLoopNodes->Node(cBVAV.AirOutNode).Temp - cBVAV.OutletTempSetPoint) > HVAC::SmallTempDiff && cBVAV.HeatCoolMode > 0 &&
+        if ((s_node->Node(cbvav.AirOutNode).Temp - cbvav.OutletTempSetPoint) > HVAC::SmallTempDiff && cbvav.HeatCoolMode > 0 &&
             PartLoadFrac < 1.0) {
             CalcCBVAV(state, CBVAVNum, FirstHVACIteration, PartLoadFrac, FullOutput, OnOffAirFlowRatio, HXUnitOn);
         }
@@ -2047,13 +1992,14 @@ namespace HVACUnitaryBypassVAV {
         Real64 OutdoorDryBulbTemp; // Dry-bulb temperature at outdoor condenser
         Real64 OutdoorBaroPress;   // Barometric pressure at outdoor condenser
 
-        auto &cBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &s_node = state.dataLoopNodes;
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
-        int OutletNode = cBVAV.AirOutNode;
-        int InletNode = cBVAV.AirInNode;
-        if (cBVAV.CondenserNodeNum > 0) {
-            OutdoorDryBulbTemp = state.dataLoopNodes->Node(cBVAV.CondenserNodeNum).Temp;
-            OutdoorBaroPress = state.dataLoopNodes->Node(cBVAV.CondenserNodeNum).Press;
+        int OutletNode = cbvav.AirOutNode;
+        int InletNode = cbvav.AirInNode;
+        if (cbvav.CondenserNodeNum > 0) {
+            OutdoorDryBulbTemp = s_node->Node(cbvav.CondenserNodeNum).Temp;
+            OutdoorBaroPress = s_node->Node(cbvav.CondenserNodeNum).Press;
         } else {
             OutdoorDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
             OutdoorBaroPress = state.dataEnvrn->OutBaroPress;
@@ -2062,205 +2008,200 @@ namespace HVACUnitaryBypassVAV {
         state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = 0.0;
 
         // Bypass excess system air through bypass duct and calculate new mixed air conditions at OA mixer inlet node
-        if (cBVAV.plenumIndex > 0 || cBVAV.mixerIndex > 0) {
-            Real64 saveMixerInletAirNodeFlow = state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate;
-            state.dataLoopNodes->Node(cBVAV.MixerInletAirNode) = state.dataLoopNodes->Node(InletNode);
-            state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate = saveMixerInletAirNodeFlow;
+        if (cbvav.plenumIndex > 0 || cbvav.mixerIndex > 0) {
+            Real64 saveMixerInletAirNodeFlow = s_node->Node(cbvav.MixerInletAirNode).MassFlowRate;
+            s_node->Node(cbvav.MixerInletAirNode) = s_node->Node(InletNode);
+            s_node->Node(cbvav.MixerInletAirNode).MassFlowRate = saveMixerInletAirNodeFlow;
         } else {
-            state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).Temp =
-                (1.0 - state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction) * state.dataLoopNodes->Node(InletNode).Temp +
-                state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * state.dataLoopNodes->Node(OutletNode).Temp;
-            state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).HumRat =
-                (1.0 - state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction) * state.dataLoopNodes->Node(InletNode).HumRat +
-                state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * state.dataLoopNodes->Node(OutletNode).HumRat;
-            state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).Enthalpy = Psychrometrics::PsyHFnTdbW(
-                state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).Temp, state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).HumRat);
+            s_node->Node(cbvav.MixerInletAirNode).Temp =
+                (1.0 - state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction) * s_node->Node(InletNode).Temp +
+                state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * s_node->Node(OutletNode).Temp;
+            s_node->Node(cbvav.MixerInletAirNode).HumRat =
+                (1.0 - state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction) * s_node->Node(InletNode).HumRat +
+                state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * s_node->Node(OutletNode).HumRat;
+            s_node->Node(cbvav.MixerInletAirNode).Enthalpy = Psychrometrics::PsyHFnTdbW(
+                s_node->Node(cbvav.MixerInletAirNode).Temp, s_node->Node(cbvav.MixerInletAirNode).HumRat);
         }
-        MixedAir::SimOAMixer(state, cBVAV.OAMixName, cBVAV.OAMixIndex);
+        MixedAir::SimOAMixer(state, cbvav.OAMixName, cbvav.OAMixIndex);
 
-        if (cBVAV.fanPlace == HVAC::FanPlace::BlowThru) {
-            state.dataFans->fans(cBVAV.FanIndex)
+        if (cbvav.fanPlace == HVAC::FanPlace::BlowThru) {
+            state.dataFans->fans(cbvav.FanIndex)
                 ->simulate(state, FirstHVACIteration, state.dataHVACUnitaryBypassVAV->FanSpeedRatio, _, 1.0 / OnOffAirFlowRatio);
         }
         // Simulate cooling coil if zone load is negative (cooling load)
-        if (cBVAV.HeatCoolMode == CoolingMode) {
-            if (OutdoorDryBulbTemp >= cBVAV.MinOATCompressor) {
-                switch (cBVAV.CoolCoilType) {
-                case HVAC::CoilType::DXCoolingHXAssisted: {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                        cBVAV.DXCoolCoilName,
-                                                                        FirstHVACIteration,
-                                                                        HVAC::CompressorOp::On,
-                                                                        PartLoadFrac,
-                                                                        cBVAV.CoolCoilCompIndex,
-                                                                        HVAC::FanOp::Continuous,
-                                                                        HXUnitOn);
-                    if (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp <= cBVAV.CoilTempSetPoint) {
+        if (cbvav.HeatCoolMode == CoolingMode) {
+            if (OutdoorDryBulbTemp >= cbvav.MinOATCompressor) {
+                if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                           cbvav.CoolCoilNum,
+                                                           FirstHVACIteration,
+                                                           HVAC::CompressorOp::On,
+                                                           PartLoadFrac,
+                                                           HVAC::FanOp::Continuous,
+                                                           HXUnitOn);
+                    if (s_node->Node(cbvav.CoolCoilAirInletNode).Temp <= cbvav.CoilTempSetPoint) {
                         //         If coil inlet temp is already below the setpoint, simulated with coil off
                         PartLoadFrac = 0.0;
-                        HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                            cBVAV.DXCoolCoilName,
-                                                                            FirstHVACIteration,
-                                                                            HVAC::CompressorOp::Off,
-                                                                            PartLoadFrac,
-                                                                            cBVAV.CoolCoilCompIndex,
-                                                                            HVAC::FanOp::Continuous,
-                                                                            HXUnitOn);
-                    } else if (state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp < cBVAV.CoilTempSetPoint) {
+                        HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                               cbvav.CoolCoilNum,
+                                                               FirstHVACIteration,
+                                                               HVAC::CompressorOp::Off,
+                                                               PartLoadFrac,
+                                                               HVAC::FanOp::Continuous,
+                                                               HXUnitOn);
+
+                    } else if (s_node->Node(cbvav.CoolCoilAirOutletNode).Temp < cbvav.CoilTempSetPoint) {
                         auto f = [&state, CBVAVNum, FirstHVACIteration, HXUnitOn](Real64 const PartLoadFrac) {
-                            auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
-                            HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                                thisCBVAV.DXCoolCoilName,
-                                                                                FirstHVACIteration,
-                                                                                HVAC::CompressorOp::On,
-                                                                                PartLoadFrac,
-                                                                                thisCBVAV.CoolCoilCompIndex,
-                                                                                HVAC::FanOp::Continuous,
-                                                                                HXUnitOn);
-
-                            Real64 OutletAirTemp = state.dataLoopNodes->Node(thisCBVAV.DXCoilOutletNode).Temp;
-                            return thisCBVAV.CoilTempSetPoint - OutletAirTemp;
+                            auto &s_node = state.dataLoopNodes;
+                            auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
+                            HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                                   cbvav.CoolCoilNum,
+                                                                   FirstHVACIteration,
+                                                                   HVAC::CompressorOp::On,
+                                                                   PartLoadFrac,
+                                                                   HVAC::FanOp::Continuous,
+                                                                   HXUnitOn);
+
+                            Real64 OutletAirTemp = s_node->Node(cbvav.CoolCoilAirOutletNode).Temp;
+                            return cbvav.CoilTempSetPoint - OutletAirTemp;
                         };
                         General::SolveRoot(state, HVAC::SmallTempDiff, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
-                        HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                            cBVAV.DXCoolCoilName,
-                                                                            FirstHVACIteration,
-                                                                            HVAC::CompressorOp::On,
-                                                                            PartLoadFrac,
-                                                                            cBVAV.CoolCoilCompIndex,
-                                                                            HVAC::FanOp::Continuous,
-                                                                            HXUnitOn);
+                        HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                               cbvav.CoolCoilNum,
+                                                               FirstHVACIteration,
+                                                               HVAC::CompressorOp::On,
+                                                               PartLoadFrac,
+                                                               HVAC::FanOp::Continuous,
+                                                               HXUnitOn);
                         if (SolFla == -1 && !state.dataGlobal->WarmupFlag) {
-                            if (cBVAV.HXDXIterationExceeded < 1) {
-                                ++cBVAV.HXDXIterationExceeded;
+                            if (cbvav.HXDXIterationExceeded < 1) {
+                                ++cbvav.HXDXIterationExceeded;
                                 ShowWarningError(state,
                                                  format("Iteration limit exceeded calculating HX assisted DX unit part-load ratio, for unit = {}",
-                                                        cBVAV.DXCoolCoilName));
+                                                        cbvav.CoolCoilName));
                                 ShowContinueError(state, format("Calculated part-load ratio = {:.3R}", PartLoadFrac));
                                 ShowContinueErrorTimeStamp(
                                     state, "The calculated part-load ratio will be used and the simulation continues. Occurrence info:");
                             } else {
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
-                                    cBVAV.Name + ", Iteration limit exceeded for HX assisted DX unit part-load ratio error continues.",
-                                    cBVAV.HXDXIterationExceededIndex,
+                                    cbvav.Name + ", Iteration limit exceeded for HX assisted DX unit part-load ratio error continues.",
+                                    cbvav.HXDXIterationExceededIndex,
                                     PartLoadFrac,
                                     PartLoadFrac);
                             }
                         } else if (SolFla == -2 && !state.dataGlobal->WarmupFlag) {
                             PartLoadFrac = max(0.0,
                                                min(1.0,
-                                                   (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp - cBVAV.CoilTempSetPoint) /
-                                                       (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp -
-                                                        state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp)));
-                            if (cBVAV.HXDXIterationFailed < 1) {
-                                ++cBVAV.HXDXIterationFailed;
+                                                   (s_node->Node(cbvav.CoolCoilAirInletNode).Temp - cbvav.CoilTempSetPoint) /
+                                                       (s_node->Node(cbvav.CoolCoilAirInletNode).Temp -
+                                                        s_node->Node(cbvav.CoolCoilAirOutletNode).Temp)));
+                            if (cbvav.HXDXIterationFailed < 1) {
+                                ++cbvav.HXDXIterationFailed;
                                 ShowSevereError(
                                     state,
                                     format("HX assisted DX unit part-load ratio calculation failed: part-load ratio limits exceeded, for unit = {}",
-                                           cBVAV.DXCoolCoilName));
+                                           cbvav.CoolCoilName));
                                 ShowContinueErrorTimeStamp(
                                     state,
                                     format("An estimated part-load ratio of {:.3R}will be used and the simulation continues. Occurrence info:",
                                            PartLoadFrac));
                             } else {
                                 ShowRecurringWarningErrorAtEnd(state,
-                                                               cBVAV.Name +
+                                                               cbvav.Name +
                                                                    ", Part-load ratio calculation failed for HX assisted DX unit error continues.",
-                                                               cBVAV.HXDXIterationFailedIndex,
+                                                               cbvav.HXDXIterationFailedIndex,
                                                                PartLoadFrac,
                                                                PartLoadFrac);
                             }
                         }
                     }
-                } break;
-                case HVAC::CoilType::DXCoolingSingleSpeed: {
+                    
+                } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                     DXCoils::SimDXCoil(state,
-                                       cBVAV.DXCoolCoilName,
+                                       cbvav.CoolCoilNum,
                                        HVAC::CompressorOp::On,
                                        FirstHVACIteration,
-                                       cBVAV.CoolCoilCompIndex,
                                        HVAC::FanOp::Continuous,
                                        PartLoadFrac,
                                        OnOffAirFlowRatio);
-                    if (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp <= cBVAV.CoilTempSetPoint) {
+                    if (s_node->Node(cbvav.CoolCoilAirInletNode).Temp <= cbvav.CoilTempSetPoint) {
                         //         If coil inlet temp is already below the setpoint, simulated with coil off
                         PartLoadFrac = 0.0;
                         DXCoils::SimDXCoil(state,
-                                           cBVAV.DXCoolCoilName,
+                                           cbvav.CoolCoilNum,
                                            HVAC::CompressorOp::On,
                                            FirstHVACIteration,
-                                           cBVAV.CoolCoilCompIndex,
                                            HVAC::FanOp::Continuous,
                                            PartLoadFrac,
                                            OnOffAirFlowRatio);
-                    } else if (state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp < cBVAV.CoilTempSetPoint) {
+                    } else if (s_node->Node(cbvav.CoolCoilAirOutletNode).Temp < cbvav.CoilTempSetPoint) {
                         auto f = [&state, CBVAVNum, OnOffAirFlowRatio](Real64 const PartLoadFrac) {
-                            auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+                            auto &s_node = state.dataLoopNodes;
+                            auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
                             DXCoils::CalcDoe2DXCoil(state,
-                                                    thisCBVAV.CoolCoilCompIndex,
+                                                    cbvav.CoolCoilNum,
                                                     HVAC::CompressorOp::On,
                                                     false,
                                                     PartLoadFrac,
                                                     HVAC::FanOp::Continuous,
                                                     _,
                                                     OnOffAirFlowRatio);
-                            Real64 OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(thisCBVAV.CoolCoilCompIndex);
-                            return thisCBVAV.CoilTempSetPoint - OutletAirTemp;
+                            Real64 OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(cbvav.CoolCoilNum);
+                            return cbvav.CoilTempSetPoint - OutletAirTemp;
                         };
                         General::SolveRoot(state, HVAC::SmallTempDiff, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         DXCoils::SimDXCoil(state,
-                                           cBVAV.DXCoolCoilName,
+                                           cbvav.CoolCoilNum,
                                            HVAC::CompressorOp::On,
                                            FirstHVACIteration,
-                                           cBVAV.CoolCoilCompIndex,
                                            HVAC::FanOp::Continuous,
                                            PartLoadFrac,
                                            OnOffAirFlowRatio);
                         if (SolFla == -1 && !state.dataGlobal->WarmupFlag) {
-                            if (cBVAV.DXIterationExceeded < 1) {
-                                ++cBVAV.DXIterationExceeded;
+                            if (cbvav.DXIterationExceeded < 1) {
+                                ++cbvav.DXIterationExceeded;
                                 ShowWarningError(
                                     state,
-                                    format("Iteration limit exceeded calculating DX unit part-load ratio, for unit = {}", cBVAV.DXCoolCoilName));
+                                    format("Iteration limit exceeded calculating DX unit part-load ratio, for unit = {}", cbvav.CoolCoilName));
                                 ShowContinueError(state, format("Calculated part-load ratio = {:.3R}", PartLoadFrac));
                                 ShowContinueErrorTimeStamp(
                                     state, "The calculated part-load ratio will be used and the simulation continues. Occurrence info:");
                             } else {
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
-                                    cBVAV.Name + ", Iteration limit exceeded for DX unit part-load ratio calculation error continues.",
-                                    cBVAV.DXIterationExceededIndex,
+                                    cbvav.Name + ", Iteration limit exceeded for DX unit part-load ratio calculation error continues.",
+                                    cbvav.DXIterationExceededIndex,
                                     PartLoadFrac,
                                     PartLoadFrac);
                             }
                         } else if (SolFla == -2 && !state.dataGlobal->WarmupFlag) {
                             PartLoadFrac = max(0.0,
                                                min(1.0,
-                                                   (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp - cBVAV.CoilTempSetPoint) /
-                                                       (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp -
-                                                        state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp)));
-                            if (cBVAV.DXIterationFailed < 1) {
-                                ++cBVAV.DXIterationFailed;
+                                                   (s_node->Node(cbvav.CoolCoilAirInletNode).Temp - cbvav.CoilTempSetPoint) /
+                                                       (s_node->Node(cbvav.CoolCoilAirInletNode).Temp -
+                                                        s_node->Node(cbvav.CoolCoilAirOutletNode).Temp)));
+                            if (cbvav.DXIterationFailed < 1) {
+                                ++cbvav.DXIterationFailed;
                                 ShowSevereError(state,
                                                 format("DX unit part-load ratio calculation failed: part-load ratio limits exceeded, for unit = {}",
-                                                       cBVAV.DXCoolCoilName));
+                                                       cbvav.CoolCoilName));
                                 ShowContinueErrorTimeStamp(
                                     state,
                                     format("An estimated part-load ratio of {:.3R}will be used and the simulation continues. Occurrence info:",
                                            PartLoadFrac));
                             } else {
                                 ShowRecurringWarningErrorAtEnd(state,
-                                                               cBVAV.Name + ", Part-load ratio calculation failed for DX unit error continues.",
-                                                               cBVAV.DXIterationFailedIndex,
+                                                               cbvav.Name + ", Part-load ratio calculation failed for DX unit error continues.",
+                                                               cbvav.DXIterationFailedIndex,
                                                                PartLoadFrac,
                                                                PartLoadFrac);
                             }
                         }
                     }
-                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cBVAV.DXCoolCoilIndexNum);
-                } break;
-                case HVAC::CoilType::CoolingAirToAirVariableSpeed: {
+                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cbvav.CoolCoilNum);
+
+                } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     Real64 QZnReq(0.0);                 // Zone load (W), input to variable-speed DX coil
                     Real64 QLatReq(0.0);                // Zone latent load, input to variable-speed DX coil
                     Real64 LocalOnOffAirFlowRatio(1.0); // ratio of compressor on flow to average flow over time step
@@ -2268,12 +2209,11 @@ namespace HVACUnitaryBypassVAV {
                     Real64 SpeedRatio(0.0);
                     int SpeedNum(1);
                     bool errorFlag(false);
-                    int maxNumSpeeds = VariableSpeedCoils::GetVSCoilNumOfSpeeds(state, cBVAV.DXCoolCoilName, errorFlag);
-                    Real64 DesOutTemp = cBVAV.CoilTempSetPoint;
+                    int maxNumSpeeds = VariableSpeedCoils::GetCoilNumOfSpeeds(state, cbvav.CoolCoilNum);
+                    Real64 DesOutTemp = cbvav.CoilTempSetPoint;
                     // Get no load result
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              cBVAV.DXCoolCoilName,
-                                                              cBVAV.CoolCoilCompIndex,
+                                                              cbvav.CoolCoilNum,
                                                               HVAC::FanOp::Continuous,
                                                               HVAC::CompressorOp::Off,
                                                               LocalPartLoadFrac,
@@ -2282,11 +2222,11 @@ namespace HVACUnitaryBypassVAV {
                                                               QZnReq,
                                                               QLatReq);
 
-                    Real64 NoOutput = state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).MassFlowRate *
-                                      (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp,
-                                                                  state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat) -
-                                       Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp,
-                                                                  state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat));
+                    Real64 NoOutput = s_node->Node(cbvav.CoolCoilAirInletNode).MassFlowRate *
+                                      (Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirOutletNode).Temp,
+                                                                  s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat) -
+                                       Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirInletNode).Temp,
+                                                                  s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat));
 
                     // Get full load result
                     LocalPartLoadFrac = 1.0;
@@ -2294,8 +2234,7 @@ namespace HVACUnitaryBypassVAV {
                     SpeedRatio = 1.0;
                     QZnReq = 0.001; // to indicate the coil is running
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              cBVAV.DXCoolCoilName,
-                                                              cBVAV.CoolCoilCompIndex,
+                                                              cbvav.CoolCoilNum,
                                                               HVAC::FanOp::Continuous,
                                                               HVAC::CompressorOp::On,
                                                               LocalPartLoadFrac,
@@ -2304,15 +2243,15 @@ namespace HVACUnitaryBypassVAV {
                                                               QZnReq,
                                                               QLatReq);
 
-                    Real64 FullOutput = state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).MassFlowRate *
-                                        (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp,
-                                                                    state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat) -
-                                         Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp,
-                                                                    state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat));
-                    Real64 ReqOutput = state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).MassFlowRate *
-                                       (Psychrometrics::PsyHFnTdbW(DesOutTemp, state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat) -
-                                        Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp,
-                                                                   state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat));
+                    Real64 FullOutput = s_node->Node(cbvav.CoolCoilAirInletNode).MassFlowRate *
+                                        (Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirOutletNode).Temp,
+                                                                    s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat) -
+                                         Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirInletNode).Temp,
+                                                                    s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat));
+                    Real64 ReqOutput = s_node->Node(cbvav.CoolCoilAirInletNode).MassFlowRate *
+                                       (Psychrometrics::PsyHFnTdbW(DesOutTemp, s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat) -
+                                        Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirInletNode).Temp,
+                                                                   s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat));
 
                     Real64 loadAccuracy(0.001);                  // Watts, power
                     Real64 tempAccuracy(0.001);                  // delta C, temperature
@@ -2324,8 +2263,7 @@ namespace HVACUnitaryBypassVAV {
                         QZnReq = 0.0;
                         // Get no load result
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                  cBVAV.DXCoolCoilName,
-                                                                  cBVAV.CoolCoilCompIndex,
+                                                                  cbvav.CoolCoilNum,
                                                                   HVAC::FanOp::Continuous,
                                                                   HVAC::CompressorOp::Off,
                                                                   LocalPartLoadFrac,
@@ -2345,7 +2283,7 @@ namespace HVACUnitaryBypassVAV {
                         //           OutletTempDXCoil is the full capacity outlet temperature at LocalPartLoadFrac = 1 from the CALL above. If this
                         //           temp is greater than the desired outlet temp, then run the compressor at LocalPartLoadFrac = 1, otherwise find
                         //           the operating PLR.
-                        Real64 OutletTempDXCoil = state.dataVariableSpeedCoils->VarSpeedCoil(cBVAV.CoolCoilCompIndex).OutletAirDBTemp;
+                        Real64 OutletTempDXCoil = state.dataVariableSpeedCoils->VarSpeedCoil(cbvav.CoolCoilNum).OutletAirDBTemp;
                         if (OutletTempDXCoil > DesOutTemp) {
                             LocalPartLoadFrac = 1.0;
                             SpeedNum = maxNumSpeeds;
@@ -2357,8 +2295,7 @@ namespace HVACUnitaryBypassVAV {
                             SpeedRatio = 1.0;
                             QZnReq = 0.001; // to indicate the coil is running
                             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                      cBVAV.DXCoolCoilName,
-                                                                      cBVAV.CoolCoilCompIndex,
+                                                                      cbvav.CoolCoilNum,
                                                                       HVAC::FanOp::Continuous,
                                                                       HVAC::CompressorOp::On,
                                                                       LocalPartLoadFrac,
@@ -2368,16 +2305,16 @@ namespace HVACUnitaryBypassVAV {
                                                                       QLatReq,
                                                                       LocalOnOffAirFlowRatio);
 
-                            Real64 TempSpeedOut = state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).MassFlowRate *
-                                                  (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp,
-                                                                              state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat) -
-                                                   Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp,
-                                                                              state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat));
+                            Real64 TempSpeedOut = s_node->Node(cbvav.CoolCoilAirInletNode).MassFlowRate *
+                                                  (Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirOutletNode).Temp,
+                                                                              s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat) -
+                                                   Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirInletNode).Temp,
+                                                                              s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat));
                             Real64 TempSpeedReqst =
-                                state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).MassFlowRate *
-                                (Psychrometrics::PsyHFnTdbW(DesOutTemp, state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat) -
-                                 Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp,
-                                                            state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat));
+                                s_node->Node(cbvav.CoolCoilAirInletNode).MassFlowRate *
+                                (Psychrometrics::PsyHFnTdbW(DesOutTemp, s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat) -
+                                 Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirInletNode).Temp,
+                                                            s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat));
 
                             if ((TempSpeedOut - TempSpeedReqst) > tempAccuracy) {
                                 // Check to see which speed to meet the load
@@ -2386,8 +2323,7 @@ namespace HVACUnitaryBypassVAV {
                                 for (int I = 2; I <= maxNumSpeeds; ++I) {
                                     SpeedNum = I;
                                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                              cBVAV.DXCoolCoilName,
-                                                                              cBVAV.CoolCoilCompIndex,
+                                                                              cbvav.CoolCoilNum,
                                                                               HVAC::FanOp::Continuous,
                                                                               HVAC::CompressorOp::On,
                                                                               LocalPartLoadFrac,
@@ -2397,16 +2333,16 @@ namespace HVACUnitaryBypassVAV {
                                                                               QLatReq,
                                                                               LocalOnOffAirFlowRatio);
 
-                                    TempSpeedOut = state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).MassFlowRate *
-                                                   (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp,
-                                                                               state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat) -
-                                                    Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp,
-                                                                               state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat));
+                                    TempSpeedOut = s_node->Node(cbvav.CoolCoilAirInletNode).MassFlowRate *
+                                                   (Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirOutletNode).Temp,
+                                                                               s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat) -
+                                                    Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirInletNode).Temp,
+                                                                               s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat));
                                     TempSpeedReqst =
-                                        state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).MassFlowRate *
-                                        (Psychrometrics::PsyHFnTdbW(DesOutTemp, state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat) -
-                                         Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp,
-                                                                    state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat));
+                                        s_node->Node(cbvav.CoolCoilAirInletNode).MassFlowRate *
+                                        (Psychrometrics::PsyHFnTdbW(DesOutTemp, s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat) -
+                                         Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.CoolCoilAirInletNode).Temp,
+                                                                    s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat));
 
                                     if ((TempSpeedOut - TempSpeedReqst) < tempAccuracy) {
                                         SpeedNum = I;
@@ -2415,18 +2351,17 @@ namespace HVACUnitaryBypassVAV {
                                 }
                                 // now find the speed ratio for the found speednum
                                 auto f = [&state, CBVAVNum, SpeedNum, DesOutTemp](Real64 const SpeedRatio) {
-                                    auto const &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+                                    auto &s_node = state.dataLoopNodes;
+                                    auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
                                     // FUNCTION LOCAL VARIABLE DECLARATIONS:
                                     Real64 OutletAirTemp; // outlet air temperature [C]
                                     Real64 QZnReqCycling = 0.001;
                                     Real64 QLatReqCycling = 0.0;
                                     Real64 OnOffAirFlowRatioCycling = 1.0;
                                     Real64 partLoadRatio = 1.0;
-                                    int CoilIndex = thisCBVAV.CoolCoilCompIndex;
                                     HVAC::FanOp fanOp = HVAC::FanOp::Continuous;
                                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                              "",
-                                                                              CoilIndex,
+                                                                              cbvav.CoolCoilNum,
                                                                               fanOp,
                                                                               HVAC::CompressorOp::On,
                                                                               partLoadRatio,
@@ -2436,21 +2371,21 @@ namespace HVACUnitaryBypassVAV {
                                                                               QLatReqCycling,
                                                                               OnOffAirFlowRatioCycling);
 
-                                    OutletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).OutletAirDBTemp;
+                                    OutletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(cbvav.CoolCoilNum).OutletAirDBTemp;
                                     return DesOutTemp - OutletAirTemp;
                                 };
                                 General::SolveRoot(state, tempAccuracy, MaxIte, SolFla, SpeedRatio, f, 1.0e-10, 1.0);
 
                                 if (SolFla == -1) {
                                     if (!state.dataGlobal->WarmupFlag) {
-                                        if (cBVAV.DXIterationExceeded < 4) {
-                                            ++cBVAV.DXIterationExceeded;
+                                        if (cbvav.DXIterationExceeded < 4) {
+                                            ++cbvav.DXIterationExceeded;
                                             ShowWarningError(state,
                                                              format("{} - Iteration limit exceeded calculating VS DX coil speed ratio for coil named "
                                                                     "{}, in Unitary system named{}",
-                                                                    HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                                    cBVAV.DXCoolCoilName,
-                                                                    cBVAV.Name));
+                                                                    HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                                    cbvav.CoolCoilName,
+                                                                    cbvav.Name));
                                             ShowContinueError(state, format("Calculated speed ratio = {:.4R}", SpeedRatio));
                                             ShowContinueErrorTimeStamp(
                                                 state, "The calculated speed ratio will be used and the simulation continues. Occurrence info:");
@@ -2458,22 +2393,22 @@ namespace HVACUnitaryBypassVAV {
                                         ShowRecurringWarningErrorAtEnd(state,
                                                                        format("{} \"{}\" - Iteration limit exceeded calculating speed ratio error "
                                                                               "continues. Speed Ratio statistics follow.",
-                                                                              HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                                              cBVAV.DXCoolCoilName),
-                                                                       cBVAV.DXIterationExceededIndex,
+                                                                              HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                                              cbvav.CoolCoilName),
+                                                                       cbvav.DXIterationExceededIndex,
                                                                        LocalPartLoadFrac,
                                                                        LocalPartLoadFrac);
                                     }
                                 } else if (SolFla == -2) {
                                     if (!state.dataGlobal->WarmupFlag) {
-                                        if (cBVAV.DXIterationFailed < 4) {
-                                            ++cBVAV.DXIterationFailed;
+                                        if (cbvav.DXIterationFailed < 4) {
+                                            ++cbvav.DXIterationFailed;
                                             ShowWarningError(state,
                                                              format("{} - DX unit speed ratio calculation failed: solver limits exceeded, for coil "
                                                                     "named {}, in Unitary system named{}",
-                                                                    HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                                    cBVAV.DXCoolCoilName,
-                                                                    cBVAV.Name));
+                                                                    HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                                    cbvav.CoolCoilName,
+                                                                    cbvav.Name));
                                             ShowContinueError(state, format("Estimated speed ratio = {:.3R}", TempSpeedReqst / TempSpeedOut));
                                             ShowContinueErrorTimeStamp(
                                                 state, "The estimated part-load ratio will be used and the simulation continues. Occurrence info:");
@@ -2482,9 +2417,9 @@ namespace HVACUnitaryBypassVAV {
                                             state,
                                             format(
                                                 "{} \"{}\" - DX unit speed ratio calculation failed error continues. speed ratio statistics follow.",
-                                                HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                cBVAV.DXCoolCoilName),
-                                            cBVAV.DXIterationFailedIndex,
+                                                HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                cbvav.CoolCoilName),
+                                            cbvav.DXIterationFailedIndex,
                                             SpeedRatio,
                                             SpeedRatio);
                                     }
@@ -2493,15 +2428,15 @@ namespace HVACUnitaryBypassVAV {
                             } else {
                                 // cycling compressor at lowest speed number, find part load fraction
                                 auto f = [&state, CBVAVNum, DesOutTemp](Real64 const PartLoadRatio) {
-                                    auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+                                    auto &s_node = state.dataLoopNodes;
+                                    auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
                                     int speedNum = 1;
                                     Real64 speedRatio = 0.0;
                                     Real64 QZnReqCycling = 0.001;
                                     Real64 QLatReqCycling = 0.0;
                                     Real64 OnOffAirFlowRatioCycling = 1.0;
                                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                              "",
-                                                                              thisCBVAV.CoolCoilCompIndex,
+                                                                              cbvav.CoolCoilNum,
                                                                               HVAC::FanOp::Continuous,
                                                                               HVAC::CompressorOp::On,
                                                                               PartLoadRatio,
@@ -2511,20 +2446,20 @@ namespace HVACUnitaryBypassVAV {
                                                                               QLatReqCycling,
                                                                               OnOffAirFlowRatioCycling);
 
-                                    Real64 OutletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(thisCBVAV.CoolCoilCompIndex).OutletAirDBTemp;
+                                    Real64 OutletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(cbvav.CoolCoilNum).OutletAirDBTemp;
                                     return DesOutTemp - OutletAirTemp;
                                 };
                                 General::SolveRoot(state, tempAccuracy, MaxIte, SolFla, LocalPartLoadFrac, f, 1.0e-10, 1.0);
                                 if (SolFla == -1) {
                                     if (!state.dataGlobal->WarmupFlag) {
-                                        if (cBVAV.DXCyclingIterationExceeded < 4) {
-                                            ++cBVAV.DXCyclingIterationExceeded;
+                                        if (cbvav.DXCyclingIterationExceeded < 4) {
+                                            ++cbvav.DXCyclingIterationExceeded;
                                             ShowWarningError(state,
                                                              format("{} - Iteration limit exceeded calculating VS DX unit low speed cycling ratio, "
                                                                     "for coil named {}, in Unitary system named{}",
-                                                                    HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                                    cBVAV.DXCoolCoilName,
-                                                                    cBVAV.Name));
+                                                                    HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                                    cbvav.CoolCoilName,
+                                                                    cbvav.Name));
                                             ShowContinueError(state, format("Estimated cycling ratio  = {:.3R}", (TempSpeedReqst / TempSpeedOut)));
                                             ShowContinueError(state, format("Calculated cycling ratio = {:.3R}", LocalPartLoadFrac));
                                             ShowContinueErrorTimeStamp(
@@ -2534,22 +2469,22 @@ namespace HVACUnitaryBypassVAV {
                                             state,
                                             format(" {} \"{}\" - Iteration limit exceeded calculating low speed cycling ratio "
                                                    "error continues. Sensible PLR statistics follow.",
-                                                   HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                   cBVAV.DXCoolCoilName),
-                                            cBVAV.DXCyclingIterationExceededIndex,
+                                                   HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                   cbvav.CoolCoilName),
+                                            cbvav.DXCyclingIterationExceededIndex,
                                             LocalPartLoadFrac,
                                             LocalPartLoadFrac);
                                     }
                                 } else if (SolFla == -2) {
 
                                     if (!state.dataGlobal->WarmupFlag) {
-                                        if (cBVAV.DXCyclingIterationFailed < 4) {
-                                            ++cBVAV.DXCyclingIterationFailed;
+                                        if (cbvav.DXCyclingIterationFailed < 4) {
+                                            ++cbvav.DXCyclingIterationFailed;
                                             ShowWarningError(
                                                 state,
                                                 format("{} - DX unit low speed cycling ratio calculation failed: limits exceeded, for unit = {}",
-                                                       HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                       cBVAV.Name));
+                                                       HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                       cbvav.Name));
                                             ShowContinueError(state,
                                                               format("Estimated low speed cycling ratio = {:.3R}", TempSpeedReqst / TempSpeedOut));
                                             ShowContinueErrorTimeStamp(state,
@@ -2559,9 +2494,9 @@ namespace HVACUnitaryBypassVAV {
                                         ShowRecurringWarningErrorAtEnd(state,
                                                                        format("{} \"{}\" - DX unit low speed cycling ratio calculation failed error "
                                                                               "continues. cycling ratio statistics follow.",
-                                                                              HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)],
-                                                                              cBVAV.DXCoolCoilName),
-                                                                       cBVAV.DXCyclingIterationFailedIndex,
+                                                                              HVAC::coilTypeNames[(int)cbvav.coolCoilType],
+                                                                              cbvav.CoolCoilName),
+                                                                       cbvav.DXCyclingIterationFailedIndex,
                                                                        LocalPartLoadFrac,
                                                                        LocalPartLoadFrac);
                                     }
@@ -2576,10 +2511,10 @@ namespace HVACUnitaryBypassVAV {
                     } else if (LocalPartLoadFrac < 0.0) {
                         LocalPartLoadFrac = 0.0;
                     }
-                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = VariableSpeedCoils::getVarSpeedPartLoadRatio(state, cBVAV.CoolCoilCompIndex);
+                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = VariableSpeedCoils::getVarSpeedPartLoadRatio(state, cbvav.CoolCoilNum);
                     // variable-speed air-to-air cooling coil, end -------------------------
-                } break;
-                case HVAC::CoilType::DXCoolingTwoStageWHumControl: {
+
+                } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                     // Coil:Cooling:DX:TwoStageWithHumidityControlMode
                     // formerly (v3 and beyond) Coil:DX:MultiMode:CoolingEmpirical
 
@@ -2591,75 +2526,73 @@ namespace HVACUnitaryBypassVAV {
 
                     // Get full load result
                     HVAC::CoilMode DehumidMode = HVAC::CoilMode::Normal; // Dehumidification mode (0=normal, 1=enhanced)
-                    cBVAV.DehumidificationMode = DehumidMode;
+                    cbvav.DehumidificationMode = DehumidMode;
                     DXCoils::SimDXCoilMultiMode(state,
-                                                cBVAV.DXCoolCoilName,
+                                                cbvav.CoolCoilNum,
                                                 HVAC::CompressorOp::On,
                                                 FirstHVACIteration,
                                                 PartLoadFrac,
                                                 DehumidMode,
-                                                cBVAV.CoolCoilCompIndex,
                                                 HVAC::FanOp::Continuous);
-                    if (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp <= cBVAV.CoilTempSetPoint) {
+                    if (s_node->Node(cbvav.CoolCoilAirInletNode).Temp <= cbvav.CoilTempSetPoint) {
                         PartLoadFrac = 0.0;
                         DXCoils::SimDXCoilMultiMode(state,
-                                                    cBVAV.DXCoolCoilName,
+                                                    cbvav.CoolCoilNum,
                                                     HVAC::CompressorOp::On,
                                                     FirstHVACIteration,
                                                     PartLoadFrac,
                                                     DehumidMode,
-                                                    cBVAV.CoolCoilCompIndex,
                                                     HVAC::FanOp::Continuous);
-                    } else if (state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp > cBVAV.CoilTempSetPoint) {
+                    } else if (s_node->Node(cbvav.CoolCoilAirOutletNode).Temp > cbvav.CoilTempSetPoint) {
                         PartLoadFrac = 1.0;
                     } else {
                         auto f = [&state, CBVAVNum, DehumidMode](Real64 const PartLoadRatio) {
-                            auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+                            auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
                             DXCoils::SimDXCoilMultiMode(state,
-                                                        "",
+                                                        cbvav.CoolCoilName,
                                                         HVAC::CompressorOp::On,
                                                         false,
                                                         PartLoadRatio,
                                                         DehumidMode,
-                                                        thisCBVAV.CoolCoilCompIndex,
+                                                        cbvav.CoolCoilNum,
                                                         HVAC::FanOp::Continuous);
-                            return thisCBVAV.CoilTempSetPoint - state.dataDXCoils->DXCoilOutletTemp(thisCBVAV.CoolCoilCompIndex);
+                            return cbvav.CoilTempSetPoint - state.dataDXCoils->DXCoilOutletTemp(cbvav.CoolCoilNum);
                         };
                         General::SolveRoot(state, HVAC::SmallTempDiff, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         if (SolFla == -1) {
-                            if (cBVAV.MMDXIterationExceeded < 1) {
-                                ++cBVAV.MMDXIterationExceeded;
+                            if (cbvav.MMDXIterationExceeded < 1) {
+                                ++cbvav.MMDXIterationExceeded;
                                 ShowWarningError(state,
-                                                 format("Iteration limit exceeded calculating DX unit part-load ratio, for unit={}", cBVAV.Name));
+                                                 format("Iteration limit exceeded calculating DX unit part-load ratio, for unit={}", cbvav.Name));
                                 ShowContinueErrorTimeStamp(state, format("Part-load ratio returned = {:.2R}", PartLoadFrac));
                                 ShowContinueErrorTimeStamp(
                                     state, "The calculated part-load ratio will be used and the simulation continues. Occurrence info:");
                             } else {
                                 ShowRecurringWarningErrorAtEnd(state,
-                                                               cBVAV.Name +
+                                                               cbvav.Name +
                                                                    ", Iteration limit exceeded calculating DX unit part-load ratio error continues.",
-                                                               cBVAV.MMDXIterationExceededIndex,
+                                                               cbvav.MMDXIterationExceededIndex,
                                                                PartLoadFrac,
                                                                PartLoadFrac);
                             }
                         } else if (SolFla == -2) {
                             PartLoadFrac = max(0.0,
                                                min(1.0,
-                                                   (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp - cBVAV.CoilTempSetPoint) /
-                                                       (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp -
-                                                        state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp)));
-                            if (cBVAV.MMDXIterationFailed < 1) {
-                                ++cBVAV.MMDXIterationFailed;
+                                                   (s_node->Node(cbvav.CoolCoilAirInletNode).Temp - cbvav.CoilTempSetPoint) /
+                                                       (s_node->Node(cbvav.CoolCoilAirInletNode).Temp -
+                                                        s_node->Node(cbvav.CoolCoilAirOutletNode).Temp)));
+                            if (cbvav.MMDXIterationFailed < 1) {
+                                ++cbvav.MMDXIterationFailed;
                                 ShowSevereError(
                                     state,
-                                    format("DX unit part-load ratio calculation failed: part-load ratio limits exceeded, for unit={}", cBVAV.Name));
+                                    format("DX unit part-load ratio calculation failed: part-load ratio limits exceeded, for unit={}", cbvav.Name));
                                 ShowContinueError(state, format("Estimated part-load ratio = {:.3R}", PartLoadFrac));
                                 ShowContinueErrorTimeStamp(
                                     state, "The estimated part-load ratio will be used and the simulation continues. Occurrence info:");
                             } else {
                                 ShowRecurringWarningErrorAtEnd(state,
-                                                               cBVAV.Name + ", Part-load ratio calculation failed for DX unit error continues.",
-                                                               cBVAV.MMDXIterationFailedIndex,
+                                                               cbvav.Name + ", Part-load ratio calculation failed for DX unit error continues.",
+                                                               cbvav.MMDXIterationFailedIndex,
                                                                PartLoadFrac,
                                                                PartLoadFrac);
                             }
@@ -2669,80 +2602,78 @@ namespace HVACUnitaryBypassVAV {
                     // If humidity setpoint is not satisfied and humidity control type is Multimode,
                     // then turn on enhanced dehumidification mode 1
 
-                    if ((state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat > state.dataLoopNodes->Node(OutletNode).HumRatMax) &&
-                        (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).HumRat > state.dataLoopNodes->Node(OutletNode).HumRatMax) &&
-                        (cBVAV.DehumidControlType == DehumidControl::Multimode) && state.dataLoopNodes->Node(OutletNode).HumRatMax > 0.0) {
+                    if ((s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat > s_node->Node(cbvav.AirOutNode).HumRatMax) &&
+                        (s_node->Node(cbvav.CoolCoilAirInletNode).HumRat > s_node->Node(cbvav.AirOutNode).HumRatMax) &&
+                        (cbvav.DehumidControlType == DehumidControl::Multimode) && s_node->Node(cbvav.AirOutNode).HumRatMax > 0.0) {
 
                         // Determine required part load for enhanced dehumidification mode 1
 
                         // Get full load result
                         PartLoadFrac = 1.0;
                         DehumidMode = HVAC::CoilMode::Enhanced;
-                        cBVAV.DehumidificationMode = DehumidMode;
+                        cbvav.DehumidificationMode = DehumidMode;
                         DXCoils::SimDXCoilMultiMode(state,
-                                                    cBVAV.DXCoolCoilName,
+                                                    cbvav.CoolCoilNum,
                                                     HVAC::CompressorOp::On,
                                                     FirstHVACIteration,
                                                     PartLoadFrac,
                                                     DehumidMode,
-                                                    cBVAV.CoolCoilCompIndex,
                                                     HVAC::FanOp::Continuous);
-                        if (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp <= cBVAV.CoilTempSetPoint) {
+                        if (s_node->Node(cbvav.CoolCoilAirInletNode).Temp <= cbvav.CoilTempSetPoint) {
                             PartLoadFrac = 0.0;
-                        } else if (state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp > cBVAV.CoilTempSetPoint) {
+                        } else if (s_node->Node(cbvav.CoolCoilAirOutletNode).Temp > cbvav.CoilTempSetPoint) {
                             PartLoadFrac = 1.0;
                         } else {
                             auto f = [&state, CBVAVNum, DehumidMode](Real64 const PartLoadRatio) {
-                                auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+                                auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
                                 DXCoils::SimDXCoilMultiMode(state,
-                                                            "",
+                                                            cbvav.CoolCoilNum,
                                                             HVAC::CompressorOp::On,
                                                             false,
                                                             PartLoadRatio,
                                                             DehumidMode,
-                                                            thisCBVAV.CoolCoilCompIndex,
                                                             HVAC::FanOp::Continuous);
-                                return thisCBVAV.CoilTempSetPoint - state.dataDXCoils->DXCoilOutletTemp(thisCBVAV.CoolCoilCompIndex);
+                                return cbvav.CoilTempSetPoint - state.dataDXCoils->DXCoilOutletTemp(cbvav.CoolCoilNum);
                             };
                             General::SolveRoot(state, HVAC::SmallTempDiff, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                             if (SolFla == -1) {
-                                if (cBVAV.DMDXIterationExceeded < 1) {
-                                    ++cBVAV.DMDXIterationExceeded;
+                                if (cbvav.DMDXIterationExceeded < 1) {
+                                    ++cbvav.DMDXIterationExceeded;
                                     ShowWarningError(
                                         state,
                                         format("Iteration limit exceeded calculating DX unit dehumidifying part-load ratio, for unit = {}",
-                                               cBVAV.Name));
+                                               cbvav.Name));
                                     ShowContinueErrorTimeStamp(state, format("Part-load ratio returned={:.2R}", PartLoadFrac));
                                     ShowContinueErrorTimeStamp(
                                         state, "The calculated part-load ratio will be used and the simulation continues. Occurrence info:");
                                 } else {
                                     ShowRecurringWarningErrorAtEnd(
                                         state,
-                                        cBVAV.Name + ", Iteration limit exceeded calculating DX unit dehumidifying part-load ratio error continues.",
-                                        cBVAV.DMDXIterationExceededIndex,
+                                        cbvav.Name + ", Iteration limit exceeded calculating DX unit dehumidifying part-load ratio error continues.",
+                                        cbvav.DMDXIterationExceededIndex,
                                         PartLoadFrac,
                                         PartLoadFrac);
                                 }
                             } else if (SolFla == -2) {
                                 PartLoadFrac = max(0.0,
                                                    min(1.0,
-                                                       (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp - cBVAV.CoilTempSetPoint) /
-                                                           (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp -
-                                                            state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp)));
-                                if (cBVAV.DMDXIterationFailed < 1) {
-                                    ++cBVAV.DMDXIterationFailed;
+                                                       (s_node->Node(cbvav.CoolCoilAirInletNode).Temp - cbvav.CoilTempSetPoint) /
+                                                           (s_node->Node(cbvav.CoolCoilAirInletNode).Temp -
+                                                            s_node->Node(cbvav.CoolCoilAirOutletNode).Temp)));
+                                if (cbvav.DMDXIterationFailed < 1) {
+                                    ++cbvav.DMDXIterationFailed;
                                     ShowSevereError(state,
                                                     format("DX unit dehumidifying part-load ratio calculation failed: part-load ratio limits "
                                                            "exceeded, for unit = {}",
-                                                           cBVAV.Name));
+                                                           cbvav.Name));
                                     ShowContinueError(state, format("Estimated part-load ratio = {:.3R}", PartLoadFrac));
                                     ShowContinueErrorTimeStamp(
                                         state, "The estimated part-load ratio will be used and the simulation continues. Occurrence info:");
                                 } else {
                                     ShowRecurringWarningErrorAtEnd(
                                         state,
-                                        cBVAV.Name + ", Dehumidifying part-load ratio calculation failed for DX unit error continues.",
-                                        cBVAV.DMDXIterationFailedIndex,
+                                        cbvav.Name + ", Dehumidifying part-load ratio calculation failed for DX unit error continues.",
+                                        cbvav.DMDXIterationFailedIndex,
                                         PartLoadFrac,
                                         PartLoadFrac);
                                 }
@@ -2753,91 +2684,89 @@ namespace HVACUnitaryBypassVAV {
                     // If humidity setpoint is not satisfied and humidity control type is CoolReheat,
                     // then run to meet latent load
 
-                    if ((state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).HumRat > state.dataLoopNodes->Node(OutletNode).HumRatMax) &&
-                        (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).HumRat > state.dataLoopNodes->Node(OutletNode).HumRatMax) &&
-                        (cBVAV.DehumidControlType == DehumidControl::CoolReheat) && state.dataLoopNodes->Node(OutletNode).HumRatMax > 0.0) {
+                    if ((s_node->Node(cbvav.CoolCoilAirOutletNode).HumRat > s_node->Node(cbvav.AirOutNode).HumRatMax) &&
+                        (s_node->Node(cbvav.CoolCoilAirInletNode).HumRat > s_node->Node(cbvav.AirOutNode).HumRatMax) &&
+                        (cbvav.DehumidControlType == DehumidControl::CoolReheat) && s_node->Node(cbvav.AirOutNode).HumRatMax > 0.0) {
 
                         // Determine revised desired outlet temperature  - use approach temperature control strategy
                         // based on CONTROLLER:SIMPLE TEMPANDHUMRAT control type.
 
                         // Calculate the approach temperature (difference between SA dry-bulb temp and SA dew point temp)
-                        ApproachTemp = state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp -
-                                       Psychrometrics::PsyTdpFnWPb(state, state.dataLoopNodes->Node(OutletNode).HumRat, OutdoorBaroPress);
+                        ApproachTemp = s_node->Node(cbvav.CoolCoilAirOutletNode).Temp -
+                                       Psychrometrics::PsyTdpFnWPb(state, s_node->Node(cbvav.AirOutNode).HumRat, OutdoorBaroPress);
                         // Calculate the dew point temperature at the SA humidity ratio setpoint
-                        DesiredDewPoint = Psychrometrics::PsyTdpFnWPb(state, state.dataLoopNodes->Node(OutletNode).HumRatMax, OutdoorBaroPress);
+                        DesiredDewPoint = Psychrometrics::PsyTdpFnWPb(state, s_node->Node(cbvav.AirOutNode).HumRatMax, OutdoorBaroPress);
                         // Adjust the calculated dew point temperature by the approach temp
-                        cBVAV.CoilTempSetPoint = min(cBVAV.CoilTempSetPoint, (DesiredDewPoint + ApproachTemp));
+                        cbvav.CoilTempSetPoint = min(cbvav.CoilTempSetPoint, (DesiredDewPoint + ApproachTemp));
 
                         // Determine required part load for cool reheat at adjusted DesiredOutletTemp
 
                         // Get full load result
                         PartLoadFrac = 1.0;
                         DehumidMode = HVAC::CoilMode::Normal;
-                        cBVAV.DehumidificationMode = DehumidMode;
+                        cbvav.DehumidificationMode = DehumidMode;
                         DXCoils::SimDXCoilMultiMode(state,
-                                                    cBVAV.DXCoolCoilName,
+                                                    cbvav.CoolCoilNum,
                                                     HVAC::CompressorOp::On,
                                                     FirstHVACIteration,
                                                     PartLoadFrac,
                                                     DehumidMode,
-                                                    cBVAV.CoolCoilCompIndex,
                                                     HVAC::FanOp::Continuous);
-                        if (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp <= cBVAV.CoilTempSetPoint) {
+                        if (s_node->Node(cbvav.CoolCoilAirInletNode).Temp <= cbvav.CoilTempSetPoint) {
                             PartLoadFrac = 0.0;
-                        } else if (state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp > cBVAV.CoilTempSetPoint) {
+                        } else if (s_node->Node(cbvav.CoolCoilAirOutletNode).Temp > cbvav.CoilTempSetPoint) {
                             PartLoadFrac = 1.0;
                         } else {
                             auto f = [&state, CBVAVNum, DehumidMode](Real64 const PartLoadRatio) {
-                                auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+                                auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
                                 DXCoils::SimDXCoilMultiMode(state,
-                                                            "",
+                                                            cbvav.CoolCoilNum,
                                                             HVAC::CompressorOp::On,
                                                             false,
                                                             PartLoadRatio,
                                                             DehumidMode,
-                                                            thisCBVAV.CoolCoilCompIndex,
                                                             HVAC::FanOp::Continuous);
-                                return thisCBVAV.CoilTempSetPoint - state.dataDXCoils->DXCoilOutletTemp(thisCBVAV.CoolCoilCompIndex);
+                                return cbvav.CoilTempSetPoint - state.dataDXCoils->DXCoilOutletTemp(cbvav.CoolCoilNum);
                             };
                             General::SolveRoot(state, HVAC::SmallTempDiff, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                             if (SolFla == -1) {
-                                if (cBVAV.CRDXIterationExceeded < 1) {
-                                    ++cBVAV.CRDXIterationExceeded;
+                                if (cbvav.CRDXIterationExceeded < 1) {
+                                    ++cbvav.CRDXIterationExceeded;
                                     ShowWarningError(state,
                                                      format("Iteration limit exceeded calculating DX unit cool reheat part-load ratio, for unit = {}",
-                                                            cBVAV.Name));
+                                                            cbvav.Name));
                                     ShowContinueErrorTimeStamp(state, format("Part-load ratio returned = {:.2R}", PartLoadFrac));
                                     ShowContinueErrorTimeStamp(
                                         state, "The calculated part-load ratio will be used and the simulation continues. Occurrence info:");
                                 } else {
                                     ShowRecurringWarningErrorAtEnd(
                                         state,
-                                        cBVAV.Name + ", Iteration limit exceeded calculating cool reheat part-load ratio DX unit error continues.",
-                                        cBVAV.CRDXIterationExceededIndex,
+                                        cbvav.Name + ", Iteration limit exceeded calculating cool reheat part-load ratio DX unit error continues.",
+                                        cbvav.CRDXIterationExceededIndex,
                                         PartLoadFrac,
                                         PartLoadFrac);
                                 }
                             } else if (SolFla == -2) {
                                 PartLoadFrac = max(0.0,
                                                    min(1.0,
-                                                       (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp - cBVAV.CoilTempSetPoint) /
-                                                           (state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp -
-                                                            state.dataLoopNodes->Node(cBVAV.DXCoilOutletNode).Temp)));
-                                if (cBVAV.CRDXIterationFailed < 1) {
-                                    ++cBVAV.CRDXIterationFailed;
+                                                       (s_node->Node(cbvav.CoolCoilAirInletNode).Temp - cbvav.CoilTempSetPoint) /
+                                                           (s_node->Node(cbvav.CoolCoilAirInletNode).Temp -
+                                                            s_node->Node(cbvav.CoolCoilAirOutletNode).Temp)));
+                                if (cbvav.CRDXIterationFailed < 1) {
+                                    ++cbvav.CRDXIterationFailed;
                                     ShowSevereError(
                                         state,
                                         format(
                                             "DX unit cool reheat part-load ratio calculation failed: part-load ratio limits exceeded, for unit = {}",
-                                            cBVAV.Name));
+                                            cbvav.Name));
                                     ShowContinueError(state, format("Estimated part-load ratio = {:.3R}", PartLoadFrac));
                                     ShowContinueErrorTimeStamp(
                                         state, "The estimated part-load ratio will be used and the simulation continues. Occurrence info:");
                                 } else {
                                     ShowRecurringWarningErrorAtEnd(
                                         state,
-                                        cBVAV.Name + ", Dehumidifying part-load ratio calculation failed for DX unit error continues.",
-                                        cBVAV.DMDXIterationFailedIndex,
+                                        cbvav.Name + ", Dehumidifying part-load ratio calculation failed for DX unit error continues.",
+                                        cbvav.DMDXIterationFailedIndex,
                                         PartLoadFrac,
                                         PartLoadFrac);
                                 }
@@ -2850,46 +2779,45 @@ namespace HVACUnitaryBypassVAV {
                     } else if (PartLoadFrac < 0.0) {
                         PartLoadFrac = 0.0;
                     }
-                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cBVAV.DXCoolCoilIndexNum);
-                } break;
-                default: {
-                    ShowFatalError(
-                        state, format("SimCBVAV System: Invalid DX Cooling Coil={}", HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.CoolCoilType)]));
-                } break;
+                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cbvav.CoolCoilNum);
+
+                } else {
+                    ShowFatalError(state, format("SimCBVAV System: Invalid DX Cooling Coil={}", HVAC::coilTypeNames[(int)cbvav.coolCoilType]));
                 }
+                
             } else { // IF(OutdoorDryBulbTemp .GE. cBVAV%MinOATCompressor)THEN
                 //     Simulate DX cooling coil with compressor off
-                if (cBVAV.CoolCoilType == HVAC::CoilType::DXCoolingHXAssisted) {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                        cBVAV.DXCoolCoilName,
-                                                                        FirstHVACIteration,
-                                                                        HVAC::CompressorOp::Off,
-                                                                        0.0,
-                                                                        cBVAV.CoolCoilCompIndex,
-                                                                        HVAC::FanOp::Continuous,
-                                                                        HXUnitOn);
-                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cBVAV.DXCoolCoilIndexNum);
-                } else if (cBVAV.CoolCoilType == HVAC::CoilType::DXCoolingSingleSpeed) {
+                if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                           cbvav.CoolCoilNum,
+                                                           FirstHVACIteration,
+                                                           HVAC::CompressorOp::Off,
+                                                           0.0,
+                                                           HVAC::FanOp::Continuous,
+                                                           HXUnitOn);
+                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cbvav.CoolCoilNum);
+
+                } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                     DXCoils::SimDXCoil(state,
-                                       cBVAV.DXCoolCoilName,
+                                       cbvav.CoolCoilNum,
                                        HVAC::CompressorOp::Off,
                                        FirstHVACIteration,
-                                       cBVAV.CoolCoilCompIndex,
                                        HVAC::FanOp::Continuous,
                                        0.0,
                                        OnOffAirFlowRatio);
-                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cBVAV.DXCoolCoilIndexNum);
-                } else if (cBVAV.CoolCoilType == HVAC::CoilType::DXCoolingTwoStageWHumControl) {
+                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cbvav.CoolCoilNum);
+                    
+                } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                     DXCoils::SimDXCoilMultiMode(state,
-                                                cBVAV.DXCoolCoilName,
+                                                cbvav.CoolCoilNum,
                                                 HVAC::CompressorOp::Off,
                                                 FirstHVACIteration,
                                                 0.0,
                                                 HVAC::CoilMode::Normal,
-                                                cBVAV.CoolCoilCompIndex,
                                                 HVAC::FanOp::Continuous);
-                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cBVAV.DXCoolCoilIndexNum);
-                } else if (cBVAV.CoolCoilType == HVAC::CoilType::CoolingAirToAirVariableSpeed) {
+                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cbvav.CoolCoilNum);
+                    
+                } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     // Real64 PartLoadFrac(0.0);
                     Real64 LocalPartLoadFrac = 0.0;
                     Real64 QZnReq = 0.0;  // Zone load (W), input to variable-speed DX coil
@@ -2898,8 +2826,7 @@ namespace HVACUnitaryBypassVAV {
                     int SpeedNum = 1;
                     // Get no load result
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              cBVAV.DXCoolCoilName,
-                                                              cBVAV.CoolCoilCompIndex,
+                                                              cbvav.CoolCoilNum,
                                                               HVAC::FanOp::Continuous,
                                                               HVAC::CompressorOp::Off,
                                                               LocalPartLoadFrac,
@@ -2907,31 +2834,31 @@ namespace HVACUnitaryBypassVAV {
                                                               SpeedRatio,
                                                               QZnReq,
                                                               QLatReq);
-                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = VariableSpeedCoils::getVarSpeedPartLoadRatio(state, cBVAV.CoolCoilCompIndex);
+                    state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = VariableSpeedCoils::getVarSpeedPartLoadRatio(state, cbvav.CoolCoilNum);
                 }
             }
 
             // Simulate cooling coil with compressor off if zone requires heating
         } else { // HeatCoolMode == HeatingMode and no cooling is required, set PLR to 0
-            if (cBVAV.CoolCoilType == HVAC::CoilType::DXCoolingHXAssisted) {
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                    cBVAV.DXCoolCoilName,
-                                                                    FirstHVACIteration,
-                                                                    HVAC::CompressorOp::Off,
-                                                                    0.0,
-                                                                    cBVAV.CoolCoilCompIndex,
-                                                                    HVAC::FanOp::Continuous,
-                                                                    HXUnitOn);
-            } else if (cBVAV.CoolCoilType == HVAC::CoilType::DXCoolingSingleSpeed) {
+            if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                       cbvav.CoolCoilNum,
+                                                       FirstHVACIteration,
+                                                       HVAC::CompressorOp::Off,
+                                                       0.0,
+                                                       HVAC::FanOp::Continuous,
+                                                       HXUnitOn);
+                
+            } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                 DXCoils::SimDXCoil(state,
-                                   cBVAV.DXCoolCoilName,
+                                   cbvav.CoolCoilNum,
                                    HVAC::CompressorOp::Off,
                                    FirstHVACIteration,
-                                   cBVAV.CoolCoilCompIndex,
                                    HVAC::FanOp::Continuous,
                                    0.0,
                                    OnOffAirFlowRatio);
-            } else if (cBVAV.CoolCoilType == HVAC::CoilType::CoolingAirToAirVariableSpeed) {
+                
+            } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                 Real64 QZnReq = 0.0;  // Zone load (W), input to variable-speed DX coil
                 Real64 QLatReq = 0.0; // Zone latent load, input to variable-speed DX coil
                 Real64 LocalPartLoadFrac = 0.0;
@@ -2939,8 +2866,7 @@ namespace HVACUnitaryBypassVAV {
                 int SpeedNum = 1;
                 // run model with no load
                 VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                          cBVAV.DXCoolCoilName,
-                                                          cBVAV.CoolCoilCompIndex,
+                                                          cbvav.CoolCoilNum,
                                                           HVAC::FanOp::Continuous,
                                                           HVAC::CompressorOp::Off,
                                                           LocalPartLoadFrac,
@@ -2949,64 +2875,61 @@ namespace HVACUnitaryBypassVAV {
                                                           QZnReq,
                                                           QLatReq);
 
-            } else if (cBVAV.CoolCoilType == HVAC::CoilType::DXCoolingTwoStageWHumControl) {
+            } else if (cbvav.coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                 DXCoils::SimDXCoilMultiMode(state,
-                                            cBVAV.DXCoolCoilName,
+                                            cbvav.CoolCoilNum,
                                             HVAC::CompressorOp::Off,
                                             FirstHVACIteration,
                                             0.0,
                                             HVAC::CoilMode::Normal,
-                                            cBVAV.CoolCoilCompIndex,
                                             HVAC::FanOp::Continuous);
             }
         }
 
         // Simulate the heating coil based on coil type
-        switch (cBVAV.HeatCoilType) {
-        case HVAC::CoilType::DXHeatingEmpirical: {
+        switch (cbvav.heatCoilType) {
+        case HVAC::CoilType::HeatingDXSingleSpeed: {
             //   Simulate DX heating coil if zone load is positive (heating load)
-            if (cBVAV.HeatCoolMode == HeatingMode) {
-                if (OutdoorDryBulbTemp > cBVAV.MinOATCompressor) {
+            if (cbvav.HeatCoolMode == HeatingMode) {
+                if (OutdoorDryBulbTemp > cbvav.MinOATCompressor) {
                     //       simulate the DX heating coil
                     // vs coil issue
 
                     DXCoils::SimDXCoil(state,
-                                       cBVAV.HeatCoilName,
+                                       cbvav.HeatCoilNum,
                                        HVAC::CompressorOp::On,
                                        FirstHVACIteration,
-                                       cBVAV.HeatCoilIndex,
                                        HVAC::FanOp::Continuous,
                                        PartLoadFrac,
                                        OnOffAirFlowRatio);
-                    if (state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).Temp > cBVAV.CoilTempSetPoint &&
-                        state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).Temp < cBVAV.CoilTempSetPoint) {
+                    if (s_node->Node(cbvav.HeatCoilAirOutletNode).Temp > cbvav.CoilTempSetPoint &&
+                        s_node->Node(cbvav.HeatCoilAirInletNode).Temp < cbvav.CoilTempSetPoint) {
                         // iterate to find PLR at CoilTempSetPoint
                         auto f = [&state, CBVAVNum, OnOffAirFlowRatio](Real64 const PartLoadFrac) {
-                            auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
-                            DXCoils::CalcDXHeatingCoil(state, thisCBVAV.HeatCoilIndex, PartLoadFrac, HVAC::FanOp::Continuous, OnOffAirFlowRatio);
-                            Real64 OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(thisCBVAV.HeatCoilIndex);
-                            Real64 par2 = min(thisCBVAV.CoilTempSetPoint, thisCBVAV.MaxLATHeating);
+                            auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
+                            DXCoils::CalcDXHeatingCoil(state, cbvav.HeatCoilNum, PartLoadFrac, HVAC::FanOp::Continuous, OnOffAirFlowRatio);
+                            Real64 OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(cbvav.HeatCoilNum);
+                            Real64 par2 = min(cbvav.CoilTempSetPoint, cbvav.MaxLATHeating);
                             return par2 - OutletAirTemp;
                         };
                         General::SolveRoot(state, HVAC::SmallTempDiff, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         DXCoils::SimDXCoil(state,
-                                           cBVAV.HeatCoilName,
+                                           cbvav.HeatCoilNum,
                                            HVAC::CompressorOp::On,
                                            FirstHVACIteration,
-                                           cBVAV.HeatCoilIndex,
                                            HVAC::FanOp::Continuous,
                                            PartLoadFrac,
                                            OnOffAirFlowRatio);
                         if (SolFla == -1 && !state.dataGlobal->WarmupFlag) {
                             ShowWarningError(
-                                state, format("Iteration limit exceeded calculating DX unit part-load ratio, for unit = {}", cBVAV.HeatCoilName));
+                                state, format("Iteration limit exceeded calculating DX unit part-load ratio, for unit = {}", cbvav.HeatCoilName));
                             ShowContinueError(state, format("Calculated part-load ratio = {:.3R}", PartLoadFrac));
                             ShowContinueErrorTimeStamp(state,
                                                        "The calculated part-load ratio will be used and the simulation continues. Occurrence info:");
                         } else if (SolFla == -2 && !state.dataGlobal->WarmupFlag) {
                             ShowSevereError(state,
                                             format("DX unit part-load ratio calculation failed: part-load ratio limits exceeded, for unit = {}",
-                                                   cBVAV.HeatCoilName));
+                                                   cbvav.HeatCoilName));
                             ShowContinueErrorTimeStamp(
                                 state,
                                 format("A part-load ratio of {:.3R}will be used and the simulation continues. Occurrence info:", PartLoadFrac));
@@ -3016,28 +2939,26 @@ namespace HVACUnitaryBypassVAV {
                 } else { // OAT .LT. MinOATCompressor
                     //       simulate DX heating coil with compressor off
                     DXCoils::SimDXCoil(state,
-                                       cBVAV.HeatCoilName,
+                                       cbvav.HeatCoilNum,
                                        HVAC::CompressorOp::Off,
                                        FirstHVACIteration,
-                                       cBVAV.HeatCoilIndex,
                                        HVAC::FanOp::Continuous,
                                        0.0,
                                        OnOffAirFlowRatio);
                 }
-                state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cBVAV.DXHeatCoilIndexNum);
+                state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = state.dataDXCoils->DXCoilPartLoadRatio(cbvav.HeatCoilNum);
             } else { // HeatCoolMode = CoolingMode
                 //     simulate DX heating coil with compressor off when cooling load is required
                 DXCoils::SimDXCoil(state,
-                                   cBVAV.HeatCoilName,
+                                   cbvav.HeatCoilNum,
                                    HVAC::CompressorOp::Off,
                                    FirstHVACIteration,
-                                   cBVAV.HeatCoilIndex,
                                    HVAC::FanOp::Continuous,
                                    0.0,
                                    OnOffAirFlowRatio);
             }
         } break;
-        case HVAC::CoilType::HeatingAirToAirVariableSpeed: {
+        case HVAC::CoilType::HeatingDXVariableSpeed: {
             Real64 QZnReq = 0.0;                 // Zone load (W), input to variable-speed DX coil
             Real64 QLatReq = 0.0;                // Zone latent load, input to variable-speed DX coil
             Real64 LocalOnOffAirFlowRatio = 1.0; // ratio of compressor on flow to average flow over time step
@@ -3045,12 +2966,11 @@ namespace HVACUnitaryBypassVAV {
             Real64 SpeedRatio = 0.0;
             int SpeedNum = 1;
             bool errorFlag = false;
-            int maxNumSpeeds = VariableSpeedCoils::GetVSCoilNumOfSpeeds(state, cBVAV.HeatCoilName, errorFlag);
-            Real64 DesOutTemp = cBVAV.CoilTempSetPoint;
+            int maxNumSpeeds = VariableSpeedCoils::GetCoilNumOfSpeeds(state, cbvav.HeatCoilNum);
+            Real64 DesOutTemp = cbvav.CoilTempSetPoint;
             // Get no load result
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      cBVAV.HeatCoilName,
-                                                      cBVAV.DXHeatCoilIndexNum,
+                                                      cbvav.HeatCoilNum,
                                                       HVAC::FanOp::Continuous,
                                                       HVAC::CompressorOp::Off,
                                                       LocalPartLoadFrac,
@@ -3059,12 +2979,12 @@ namespace HVACUnitaryBypassVAV {
                                                       QZnReq,
                                                       QLatReq);
 
-            Real64 NoOutput = state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).MassFlowRate *
-                              (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).Temp,
-                                                          state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).HumRat) -
-                               Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).Temp,
-                                                          state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).HumRat));
-            Real64 TempNoOutput = state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).Temp;
+            Real64 NoOutput = s_node->Node(cbvav.HeatCoilAirInletNode).MassFlowRate *
+                              (Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.HeatCoilAirOutletNode).Temp,
+                                                          s_node->Node(cbvav.HeatCoilAirInletNode).HumRat) -
+                               Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.HeatCoilAirInletNode).Temp,
+                                                          s_node->Node(cbvav.HeatCoilAirOutletNode).HumRat));
+            Real64 TempNoOutput = s_node->Node(cbvav.HeatCoilAirOutletNode).Temp;
             // Real64 NoLoadHumRatOut = VariableSpeedCoils::VarSpeedCoil( CBVAV( CBVAVNum ).CoolCoilCompIndex ).OutletAirHumRat;
 
             // Get full load result
@@ -3073,8 +2993,7 @@ namespace HVACUnitaryBypassVAV {
             SpeedRatio = 1.0;
             QZnReq = 0.001; // to indicate the coil is running
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      cBVAV.HeatCoilName,
-                                                      cBVAV.DXHeatCoilIndexNum,
+                                                      cbvav.HeatCoilNum,
                                                       HVAC::FanOp::Continuous,
                                                       HVAC::CompressorOp::On,
                                                       LocalPartLoadFrac,
@@ -3084,15 +3003,15 @@ namespace HVACUnitaryBypassVAV {
                                                       QLatReq);
 
             // Real64 FullLoadHumRatOut = VariableSpeedCoils::VarSpeedCoil( CBVAV( CBVAVNum ).CoolCoilCompIndex ).OutletAirHumRat;
-            Real64 FullOutput = state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).MassFlowRate *
-                                (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).Temp,
-                                                            state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).HumRat) -
-                                 Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).Temp,
-                                                            state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).HumRat));
-            Real64 ReqOutput = state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).MassFlowRate *
-                               (Psychrometrics::PsyHFnTdbW(DesOutTemp, state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).HumRat) -
-                                Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).Temp,
-                                                           state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).HumRat));
+            Real64 FullOutput = s_node->Node(cbvav.HeatCoilAirInletNode).MassFlowRate *
+                                (Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.HeatCoilAirOutletNode).Temp,
+                                                            s_node->Node(cbvav.HeatCoilAirOutletNode).HumRat) -
+                                 Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.HeatCoilAirInletNode).Temp,
+                                                            s_node->Node(cbvav.HeatCoilAirOutletNode).HumRat));
+            Real64 ReqOutput = s_node->Node(cbvav.HeatCoilAirInletNode).MassFlowRate *
+                               (Psychrometrics::PsyHFnTdbW(DesOutTemp, s_node->Node(cbvav.HeatCoilAirOutletNode).HumRat) -
+                                Psychrometrics::PsyHFnTdbW(s_node->Node(cbvav.HeatCoilAirInletNode).Temp,
+                                                           s_node->Node(cbvav.HeatCoilAirOutletNode).HumRat));
 
             Real64 loadAccuracy = 0.001;                  // Watts, power
             Real64 tempAccuracy = 0.001;                  // delta C, temperature
@@ -3104,8 +3023,7 @@ namespace HVACUnitaryBypassVAV {
                 QZnReq = 0.0;
                 // call again with coil off
                 VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                          cBVAV.HeatCoilName,
-                                                          cBVAV.DXHeatCoilIndexNum,
+                                                          cbvav.HeatCoilNum,
                                                           HVAC::FanOp::Continuous,
                                                           HVAC::CompressorOp::Off,
                                                           LocalPartLoadFrac,
@@ -3121,14 +3039,13 @@ namespace HVACUnitaryBypassVAV {
             } else { //  Else find how the coil is modulating (speed level and speed ratio or part load between off and speed 1) to meet the load
                 //           OutletTempDXCoil is the full capacity outlet temperature at LocalPartLoadFrac = 1 from the CALL above. If this temp is
                 //           greater than the desired outlet temp, then run the compressor at LocalPartLoadFrac = 1, otherwise find the operating PLR.
-                Real64 OutletTempDXCoil = state.dataVariableSpeedCoils->VarSpeedCoil(cBVAV.DXHeatCoilIndexNum).OutletAirDBTemp;
+                Real64 OutletTempDXCoil = state.dataVariableSpeedCoils->VarSpeedCoil(cbvav.HeatCoilNum).OutletAirDBTemp;
                 if (OutletTempDXCoil < DesOutTemp) {
                     LocalPartLoadFrac = 1.0;
                     SpeedNum = maxNumSpeeds;
                     SpeedRatio = 1.0;
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              cBVAV.HeatCoilName,
-                                                              cBVAV.DXHeatCoilIndexNum,
+                                                              cbvav.HeatCoilNum,
                                                               HVAC::FanOp::Continuous,
                                                               HVAC::CompressorOp::On,
                                                               LocalPartLoadFrac,
@@ -3144,8 +3061,7 @@ namespace HVACUnitaryBypassVAV {
                     SpeedRatio = 1.0;
                     QZnReq = 0.001; // to indicate the coil is running
                     VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              cBVAV.HeatCoilName,
-                                                              cBVAV.DXHeatCoilIndexNum,
+                                                              cbvav.HeatCoilNum,
                                                               HVAC::FanOp::Continuous,
                                                               HVAC::CompressorOp::On,
                                                               LocalPartLoadFrac,
@@ -3155,7 +3071,7 @@ namespace HVACUnitaryBypassVAV {
                                                               QLatReq,
                                                               LocalOnOffAirFlowRatio);
 
-                    Real64 TempSpeedOut = state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).Temp;
+                    Real64 TempSpeedOut = s_node->Node(cbvav.HeatCoilAirOutletNode).Temp;
                     Real64 TempSpeedOutSpeed1 = TempSpeedOut;
 
                     if ((TempSpeedOut - DesOutTemp) < tempAccuracy) {
@@ -3165,8 +3081,7 @@ namespace HVACUnitaryBypassVAV {
                         for (int I = 2; I <= maxNumSpeeds; ++I) {
                             SpeedNum = I;
                             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                      cBVAV.HeatCoilName,
-                                                                      cBVAV.DXHeatCoilIndexNum,
+                                                                      cbvav.HeatCoilNum,
                                                                       HVAC::FanOp::Continuous,
                                                                       HVAC::CompressorOp::On,
                                                                       LocalPartLoadFrac,
@@ -3176,7 +3091,7 @@ namespace HVACUnitaryBypassVAV {
                                                                       QLatReq,
                                                                       LocalOnOffAirFlowRatio);
 
-                            TempSpeedOut = state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).Temp;
+                            TempSpeedOut = s_node->Node(cbvav.HeatCoilAirOutletNode).Temp;
 
                             if ((TempSpeedOut - DesOutTemp) > tempAccuracy) {
                                 SpeedNum = I;
@@ -3184,22 +3099,22 @@ namespace HVACUnitaryBypassVAV {
                             }
                         }
                         // now find the speed ratio for the found speednum
-                        int const vsCoilIndex = cBVAV.DXHeatCoilIndexNum;
-                        auto f = [&state, vsCoilIndex, DesOutTemp, SpeedNum](Real64 const x) {
-                            return HVACDXHeatPumpSystem::VSCoilSpeedResidual(state, x, vsCoilIndex, DesOutTemp, SpeedNum, HVAC::FanOp::Continuous);
+                        int const vsCoilNum = cbvav.HeatCoilNum;
+                        auto f = [&state, vsCoilNum, DesOutTemp, SpeedNum](Real64 const x) {
+                            return HVACDXHeatPumpSystem::VSCoilSpeedResidual(state, x, vsCoilNum, DesOutTemp, SpeedNum, HVAC::FanOp::Continuous);
                         };
                         General::SolveRoot(state, tempAccuracy, MaxIte, SolFla, SpeedRatio, f, 1.0e-10, 1.0);
 
                         if (SolFla == -1) {
                             if (!state.dataGlobal->WarmupFlag) {
-                                if (cBVAV.DXHeatIterationExceeded < 4) {
-                                    ++cBVAV.DXHeatIterationExceeded;
+                                if (cbvav.DXHeatIterationExceeded < 4) {
+                                    ++cbvav.DXHeatIterationExceeded;
                                     ShowWarningError(state,
                                                      format("{} - Iteration limit exceeded calculating VS DX coil speed ratio for coil named {}, in "
                                                             "Unitary system named{}",
-                                                            HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                                            cBVAV.HeatCoilName,
-                                                            cBVAV.Name));
+                                                            HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                            cbvav.HeatCoilName,
+                                                            cbvav.Name));
                                     ShowContinueError(state, format("Calculated speed ratio = {:.4R}", SpeedRatio));
                                     ShowContinueErrorTimeStamp(
                                         state, "The calculated speed ratio will be used and the simulation continues. Occurrence info:");
@@ -3207,40 +3122,39 @@ namespace HVACUnitaryBypassVAV {
                                 ShowRecurringWarningErrorAtEnd(state,
                                                                format("{} \"{}\" - Iteration limit exceeded calculating speed ratio error continues. "
                                                                       "Speed Ratio statistics follow.",
-                                                                      HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                                                      cBVAV.HeatCoilName),
-                                                               cBVAV.DXHeatIterationExceededIndex,
+                                                                      HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                                      cbvav.HeatCoilName),
+                                                               cbvav.DXHeatIterationExceededIndex,
                                                                LocalPartLoadFrac,
                                                                LocalPartLoadFrac);
                             }
                         } else if (SolFla == -2) {
 
                             if (!state.dataGlobal->WarmupFlag) {
-                                if (cBVAV.DXHeatIterationFailed < 4) {
-                                    ++cBVAV.DXHeatIterationFailed;
+                                if (cbvav.DXHeatIterationFailed < 4) {
+                                    ++cbvav.DXHeatIterationFailed;
                                     ShowWarningError(state,
                                                      format("{} - DX unit speed ratio calculation failed: solver limits exceeded, for coil named {}, "
                                                             "in Unitary system named{}",
-                                                            HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                                            cBVAV.HeatCoilName,
-                                                            cBVAV.Name));
+                                                            HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                            cbvav.HeatCoilName,
+                                                            cbvav.Name));
                                     ShowContinueErrorTimeStamp(state,
                                                                " Speed ratio will be set to 0.5, and the simulation continues. Occurrence info:");
                                 }
                                 ShowRecurringWarningErrorAtEnd(
                                     state,
                                     format("{} \"{}\" - DX unit speed ratio calculation failed error continues. speed ratio statistics follow.",
-                                           HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                           cBVAV.HeatCoilName),
-                                    cBVAV.DXHeatIterationFailedIndex,
+                                           HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                           cbvav.HeatCoilName),
+                                    cbvav.DXHeatIterationFailedIndex,
                                     SpeedRatio,
                                     SpeedRatio);
                             }
                             SpeedRatio = 0.5;
                         }
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                  cBVAV.HeatCoilName,
-                                                                  cBVAV.DXHeatCoilIndexNum,
+                                                                  cbvav.HeatCoilNum,
                                                                   HVAC::FanOp::Continuous,
                                                                   HVAC::CompressorOp::On,
                                                                   LocalPartLoadFrac,
@@ -3251,21 +3165,21 @@ namespace HVACUnitaryBypassVAV {
                                                                   LocalOnOffAirFlowRatio);
                     } else {
                         // cycling compressor at lowest speed number, find part load fraction
-                        int VSCoilIndex = cBVAV.DXHeatCoilIndexNum;
-                        auto f = [&state, VSCoilIndex, DesOutTemp](Real64 const x) {
-                            return HVACDXHeatPumpSystem::VSCoilCyclingResidual(state, x, VSCoilIndex, DesOutTemp, HVAC::FanOp::Continuous);
+                        int VSCoilNum = cbvav.HeatCoilNum;
+                        auto f = [&state, VSCoilNum, DesOutTemp](Real64 const x) {
+                            return HVACDXHeatPumpSystem::VSCoilCyclingResidual(state, x, VSCoilNum, DesOutTemp, HVAC::FanOp::Continuous);
                         };
                         General::SolveRoot(state, tempAccuracy, MaxIte, SolFla, LocalPartLoadFrac, f, 1.0e-10, 1.0);
                         if (SolFla == -1) {
                             if (!state.dataGlobal->WarmupFlag) {
-                                if (cBVAV.DXHeatCyclingIterationExceeded < 4) {
-                                    ++cBVAV.DXHeatCyclingIterationExceeded;
+                                if (cbvav.DXHeatCyclingIterationExceeded < 4) {
+                                    ++cbvav.DXHeatCyclingIterationExceeded;
                                     ShowWarningError(state,
                                                      format("{} - Iteration limit exceeded calculating VS DX unit low speed cycling ratio, for coil "
                                                             "named {}, in Unitary system named{}",
-                                                            HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                                            cBVAV.HeatCoilName,
-                                                            cBVAV.Name));
+                                                            HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                            cbvav.HeatCoilName,
+                                                            cbvav.Name));
                                     ShowContinueError(state, format("Estimated cycling ratio  = {:.3R}", (DesOutTemp / TempSpeedOut)));
                                     ShowContinueError(state, format("Calculated cycling ratio = {:.3R}", LocalPartLoadFrac));
                                     ShowContinueErrorTimeStamp(
@@ -3274,21 +3188,21 @@ namespace HVACUnitaryBypassVAV {
                                 ShowRecurringWarningErrorAtEnd(state,
                                                                format("{} \"{}\" - Iteration limit exceeded calculating low speed cycling ratio "
                                                                       "error continues. Sensible PLR statistics follow.",
-                                                                      HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                                                      cBVAV.HeatCoilName),
-                                                               cBVAV.DXHeatCyclingIterationExceededIndex,
+                                                                      HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                                      cbvav.HeatCoilName),
+                                                               cbvav.DXHeatCyclingIterationExceededIndex,
                                                                LocalPartLoadFrac,
                                                                LocalPartLoadFrac);
                             }
                         } else if (SolFla == -2) {
 
                             if (!state.dataGlobal->WarmupFlag) {
-                                if (cBVAV.DXHeatCyclingIterationFailed < 4) {
-                                    ++cBVAV.DXHeatCyclingIterationFailed;
+                                if (cbvav.DXHeatCyclingIterationFailed < 4) {
+                                    ++cbvav.DXHeatCyclingIterationFailed;
                                     ShowWarningError(state,
                                                      format("{} - DX unit low speed cycling ratio calculation failed: limits exceeded, for unit = {}",
-                                                            HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                                            cBVAV.Name));
+                                                            HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                            cbvav.Name));
                                     ShowContinueError(state,
                                                       format("Estimated low speed cycling ratio = {:.3R}",
                                                              (DesOutTemp - TempNoOutput) / (TempSpeedOutSpeed1 - TempNoOutput)));
@@ -3298,17 +3212,16 @@ namespace HVACUnitaryBypassVAV {
                                 ShowRecurringWarningErrorAtEnd(state,
                                                                format("{} \"{}\" - DX unit low speed cycling ratio calculation failed error "
                                                                       "continues. cycling ratio statistics follow.",
-                                                                      HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)],
-                                                                      cBVAV.HeatCoilName),
-                                                               cBVAV.DXHeatCyclingIterationFailedIndex,
+                                                                      HVAC::coilTypeNames[(int)cbvav.heatCoilType],
+                                                                      cbvav.HeatCoilName),
+                                                               cbvav.DXHeatCyclingIterationFailedIndex,
                                                                LocalPartLoadFrac,
                                                                LocalPartLoadFrac);
                             }
                             LocalPartLoadFrac = (DesOutTemp - TempNoOutput) / (TempSpeedOutSpeed1 - TempNoOutput);
                         }
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                  cBVAV.HeatCoilName,
-                                                                  cBVAV.DXHeatCoilIndexNum,
+                                                                  cbvav.HeatCoilNum,
                                                                   HVAC::FanOp::Continuous,
                                                                   HVAC::CompressorOp::On,
                                                                   LocalPartLoadFrac,
@@ -3326,62 +3239,62 @@ namespace HVACUnitaryBypassVAV {
             } else if (LocalPartLoadFrac < 0.0) {
                 LocalPartLoadFrac = 0.0;
             }
-            state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = VariableSpeedCoils::getVarSpeedPartLoadRatio(state, cBVAV.DXHeatCoilIndexNum);
+            state.dataHVACUnitaryBypassVAV->SaveCompressorPLR = VariableSpeedCoils::getVarSpeedPartLoadRatio(state, cbvav.HeatCoilNum);
         } break;
         case HVAC::CoilType::HeatingGasOrOtherFuel:
         case HVAC::CoilType::HeatingElectric:
         case HVAC::CoilType::HeatingWater:
         case HVAC::CoilType::HeatingSteam: { // not a DX heating coil
-            if (cBVAV.HeatCoolMode == HeatingMode) {
-                CpAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).HumRat);
-                QHeater = state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).MassFlowRate * CpAir *
-                          (cBVAV.CoilTempSetPoint - state.dataLoopNodes->Node(cBVAV.HeatingCoilInletNode).Temp);
+            if (cbvav.HeatCoolMode == HeatingMode) {
+                CpAir = Psychrometrics::PsyCpAirFnW(s_node->Node(cbvav.HeatCoilAirInletNode).HumRat);
+                QHeater = s_node->Node(cbvav.HeatCoilAirInletNode).MassFlowRate * CpAir *
+                          (cbvav.CoilTempSetPoint - s_node->Node(cbvav.HeatCoilAirInletNode).Temp);
             } else {
                 QHeater = 0.0;
             }
             // Added None DX heating coils calling point
-            state.dataLoopNodes->Node(cBVAV.HeatingCoilOutletNode).TempSetPoint = cBVAV.CoilTempSetPoint;
-            CalcNonDXHeatingCoils(state, CBVAVNum, FirstHVACIteration, QHeater, cBVAV.fanOp, QHeaterActual);
+            s_node->Node(cbvav.HeatCoilAirOutletNode).TempSetPoint = cbvav.CoilTempSetPoint;
+            CalcNonDXHeatingCoils(state, CBVAVNum, FirstHVACIteration, QHeater, cbvav.fanOp, QHeaterActual);
         } break;
         default: {
-            ShowFatalError(state, format("SimCBVAV System: Invalid Heating Coil={}", HVAC::coilTypeNamesUC[static_cast<int>(cBVAV.HeatCoilType)]));
+            ShowFatalError(state, format("SimCBVAV System: Invalid Heating Coil={}", HVAC::coilTypeNames[(int)cbvav.heatCoilType]));
         } break;
         }
 
-        if (cBVAV.fanPlace == HVAC::FanPlace::DrawThru) {
-            state.dataFans->fans(cBVAV.FanIndex)
+        if (cbvav.fanPlace == HVAC::FanPlace::DrawThru) {
+            state.dataFans->fans(cbvav.FanIndex)
                 ->simulate(state, FirstHVACIteration, state.dataHVACUnitaryBypassVAV->FanSpeedRatio, _, 1.0 / OnOffAirFlowRatio, _);
         }
-        int splitterOutNode = cBVAV.SplitterOutletAirNode;
-        state.dataLoopNodes->Node(splitterOutNode).MassFlowRateSetPoint = state.dataLoopNodes->Node(OutletNode).MassFlowRateSetPoint;
-        state.dataLoopNodes->Node(OutletNode) = state.dataLoopNodes->Node(splitterOutNode);
-        state.dataLoopNodes->Node(OutletNode).TempSetPoint = cBVAV.OutletTempSetPoint;
-        state.dataLoopNodes->Node(OutletNode).MassFlowRate =
-            (1.0 - state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction) * state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate;
+        int splitterOutNode = cbvav.SplitterOutletAirNode;
+        s_node->Node(splitterOutNode).MassFlowRateSetPoint = s_node->Node(OutletNode).MassFlowRateSetPoint;
+        s_node->Node(OutletNode) = s_node->Node(splitterOutNode);
+        s_node->Node(OutletNode).TempSetPoint = cbvav.OutletTempSetPoint;
+        s_node->Node(OutletNode).MassFlowRate =
+            (1.0 - state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction) * s_node->Node(cbvav.MixerInletAirNode).MassFlowRate;
         // report variable
-        cBVAV.BypassMassFlowRate =
-            state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate;
+        cbvav.BypassMassFlowRate =
+            state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * s_node->Node(cbvav.MixerInletAirNode).MassFlowRate;
         // initialize bypass duct connected to mixer or plenum with flow rate and conditions
-        if (cBVAV.plenumIndex > 0 || cBVAV.mixerIndex > 0) {
-            int plenumOrMixerInletNode = cBVAV.PlenumMixerInletAirNode;
-            state.dataLoopNodes->Node(plenumOrMixerInletNode) = state.dataLoopNodes->Node(splitterOutNode);
-            state.dataLoopNodes->Node(plenumOrMixerInletNode).MassFlowRate =
-                state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * state.dataLoopNodes->Node(cBVAV.MixerInletAirNode).MassFlowRate;
-            state.dataLoopNodes->Node(plenumOrMixerInletNode).MassFlowRateMaxAvail = state.dataLoopNodes->Node(plenumOrMixerInletNode).MassFlowRate;
-            state.dataAirLoop->AirLoopFlow(cBVAV.AirLoopNumber).BypassMassFlow = state.dataLoopNodes->Node(plenumOrMixerInletNode).MassFlowRate;
+        if (cbvav.plenumIndex > 0 || cbvav.mixerIndex > 0) {
+            int plenumOrMixerInletNode = cbvav.PlenumMixerInletAirNode;
+            s_node->Node(plenumOrMixerInletNode) = s_node->Node(splitterOutNode);
+            s_node->Node(plenumOrMixerInletNode).MassFlowRate =
+                state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction * s_node->Node(cbvav.MixerInletAirNode).MassFlowRate;
+            s_node->Node(plenumOrMixerInletNode).MassFlowRateMaxAvail = s_node->Node(plenumOrMixerInletNode).MassFlowRate;
+            state.dataAirLoop->AirLoopFlow(cbvav.AirLoopNumber).BypassMassFlow = s_node->Node(plenumOrMixerInletNode).MassFlowRate;
         }
 
         // calculate sensible load met using delta enthalpy at a constant (minimum) humidity ratio)
-        MinHumRat = min(state.dataLoopNodes->Node(InletNode).HumRat, state.dataLoopNodes->Node(OutletNode).HumRat);
+        MinHumRat = min(s_node->Node(InletNode).HumRat, s_node->Node(OutletNode).HumRat);
         LoadMet =
-            state.dataLoopNodes->Node(OutletNode).MassFlowRate * (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(OutletNode).Temp, MinHumRat) -
-                                                                  Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(InletNode).Temp, MinHumRat));
+            s_node->Node(OutletNode).MassFlowRate * (Psychrometrics::PsyHFnTdbW(s_node->Node(OutletNode).Temp, MinHumRat) -
+                                                                  Psychrometrics::PsyHFnTdbW(s_node->Node(InletNode).Temp, MinHumRat));
 
         // calculate OA fraction used for zone OA volume flow rate calc
-        state.dataAirLoop->AirLoopFlow(cBVAV.AirLoopNumber).OAFrac = 0.0;
-        if (state.dataLoopNodes->Node(cBVAV.AirOutNode).MassFlowRate > 0.0) {
-            state.dataAirLoop->AirLoopFlow(cBVAV.AirLoopNumber).OAFrac =
-                state.dataLoopNodes->Node(cBVAV.MixerOutsideAirNode).MassFlowRate / state.dataLoopNodes->Node(cBVAV.AirOutNode).MassFlowRate;
+        state.dataAirLoop->AirLoopFlow(cbvav.AirLoopNumber).OAFrac = 0.0;
+        if (s_node->Node(cbvav.AirOutNode).MassFlowRate > 0.0) {
+            state.dataAirLoop->AirLoopFlow(cbvav.AirLoopNumber).OAFrac =
+                s_node->Node(cbvav.MixerOutsideAirNode).MassFlowRate / s_node->Node(cbvav.AirOutNode).MassFlowRate;
         }
     }
 
@@ -3402,33 +3315,33 @@ namespace HVACUnitaryBypassVAV {
         Real64 ZoneLoad = 0.0; // Total load in controlled zone [W]
         int lastDayOfSim(0);   // used during warmup to reset changeOverTimer since need to do same thing next warmup day
 
-        auto &cBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
         int dayOfSim = state.dataGlobal->DayOfSim; // DayOfSim increments during Warmup when it actually simulates the same day
         if (state.dataGlobal->WarmupFlag) {
             // when warmupday increments then reset timer
-            if (lastDayOfSim != dayOfSim) cBVAV.changeOverTimer = -1.0; // reset to default (thisTime always > -1)
+            if (lastDayOfSim != dayOfSim) cbvav.changeOverTimer = -1.0; // reset to default (thisTime always > -1)
             lastDayOfSim = dayOfSim;
             dayOfSim = 1; // reset so that thisTime is <= 24 during warmup
         }
         Real64 thisTime = (dayOfSim - 1) * 24 + state.dataGlobal->HourOfDay - 1 + (state.dataGlobal->TimeStep - 1) * state.dataGlobal->TimeStepZone +
                           state.dataHVACGlobal->SysTimeElapsed;
 
-        if (thisTime <= cBVAV.changeOverTimer) {
-            cBVAV.modeChanged = true;
+        if (thisTime <= cbvav.changeOverTimer) {
+            cbvav.modeChanged = true;
             return;
         }
 
         Real64 QZoneReqCool = 0.0; // Total cooling load in all controlled zones [W]
         Real64 QZoneReqHeat = 0.0; // Total heating load in all controlled zones [W]
-        cBVAV.NumZonesCooled = 0;
-        cBVAV.NumZonesHeated = 0;
-        cBVAV.HeatCoolMode = 0;
-
-        for (int ZoneNum = 1; ZoneNum <= cBVAV.NumControlledZones; ++ZoneNum) {
-            int actualZoneNum = cBVAV.ControlledZoneNum(ZoneNum);
-            int coolSeqNum = cBVAV.ZoneSequenceCoolingNum(ZoneNum);
-            int heatSeqNum = cBVAV.ZoneSequenceHeatingNum(ZoneNum);
+        cbvav.NumZonesCooled = 0;
+        cbvav.NumZonesHeated = 0;
+        cbvav.HeatCoolMode = 0;
+
+        for (int ZoneNum = 1; ZoneNum <= cbvav.NumControlledZones; ++ZoneNum) {
+            int actualZoneNum = cbvav.ControlledZoneNum(ZoneNum);
+            int coolSeqNum = cbvav.ZoneSequenceCoolingNum(ZoneNum);
+            int heatSeqNum = cbvav.ZoneSequenceHeatingNum(ZoneNum);
             if (coolSeqNum > 0 && heatSeqNum > 0) {
                 Real64 ZoneLoadToCoolSPSequenced =
                     state.dataZoneEnergyDemand->ZoneSysEnergyDemand(actualZoneNum).SequencedOutputRequiredToCoolingSP(coolSeqNum);
@@ -3448,74 +3361,74 @@ namespace HVACUnitaryBypassVAV {
             if (!state.dataZoneEnergyDemand->CurDeadBandOrSetback(actualZoneNum)) {
                 if (ZoneLoad > HVAC::SmallLoad) {
                     QZoneReqHeat += ZoneLoad;
-                    ++cBVAV.NumZonesHeated;
+                    ++cbvav.NumZonesHeated;
                 } else if (ZoneLoad < -HVAC::SmallLoad) {
                     QZoneReqCool += ZoneLoad;
-                    ++cBVAV.NumZonesCooled;
+                    ++cbvav.NumZonesCooled;
                 }
             }
         }
 
-        switch (cBVAV.PriorityControl) {
+        switch (cbvav.PriorityControl) {
         case PriorityCtrlMode::CoolingPriority: {
             if (QZoneReqCool < 0.0) {
-                cBVAV.HeatCoolMode = CoolingMode;
+                cbvav.HeatCoolMode = CoolingMode;
             } else if (QZoneReqHeat > 0.0) {
-                cBVAV.HeatCoolMode = HeatingMode;
+                cbvav.HeatCoolMode = HeatingMode;
             }
         } break;
         case PriorityCtrlMode::HeatingPriority: {
             if (QZoneReqHeat > 0.0) {
-                cBVAV.HeatCoolMode = HeatingMode;
+                cbvav.HeatCoolMode = HeatingMode;
             } else if (QZoneReqCool < 0.0) {
-                cBVAV.HeatCoolMode = CoolingMode;
+                cbvav.HeatCoolMode = CoolingMode;
             }
         } break;
         case PriorityCtrlMode::ZonePriority: {
-            if (cBVAV.NumZonesHeated > cBVAV.NumZonesCooled) {
+            if (cbvav.NumZonesHeated > cbvav.NumZonesCooled) {
                 if (QZoneReqHeat > 0.0) {
-                    cBVAV.HeatCoolMode = HeatingMode;
+                    cbvav.HeatCoolMode = HeatingMode;
                 } else if (QZoneReqCool < 0.0) {
-                    cBVAV.HeatCoolMode = CoolingMode;
+                    cbvav.HeatCoolMode = CoolingMode;
                 }
-            } else if (cBVAV.NumZonesCooled > cBVAV.NumZonesHeated) {
+            } else if (cbvav.NumZonesCooled > cbvav.NumZonesHeated) {
                 if (QZoneReqCool < 0.0) {
-                    cBVAV.HeatCoolMode = CoolingMode;
+                    cbvav.HeatCoolMode = CoolingMode;
                 } else if (QZoneReqHeat > 0.0) {
-                    cBVAV.HeatCoolMode = HeatingMode;
+                    cbvav.HeatCoolMode = HeatingMode;
                 }
             } else {
                 if (std::abs(QZoneReqCool) > std::abs(QZoneReqHeat) && QZoneReqCool != 0.0) {
-                    cBVAV.HeatCoolMode = CoolingMode;
+                    cbvav.HeatCoolMode = CoolingMode;
                 } else if (std::abs(QZoneReqCool) < std::abs(QZoneReqHeat) && QZoneReqHeat != 0.0) {
-                    cBVAV.HeatCoolMode = HeatingMode;
+                    cbvav.HeatCoolMode = HeatingMode;
                 } else if (std::abs(QZoneReqCool) == std::abs(QZoneReqHeat) && QZoneReqCool != 0.0) {
-                    cBVAV.HeatCoolMode = CoolingMode;
+                    cbvav.HeatCoolMode = CoolingMode;
                 }
             }
         } break;
         case PriorityCtrlMode::LoadPriority: {
             if (std::abs(QZoneReqCool) > std::abs(QZoneReqHeat) && QZoneReqCool != 0.0) {
-                cBVAV.HeatCoolMode = CoolingMode;
+                cbvav.HeatCoolMode = CoolingMode;
             } else if (std::abs(QZoneReqCool) < std::abs(QZoneReqHeat) && QZoneReqHeat != 0.0) {
-                cBVAV.HeatCoolMode = HeatingMode;
-            } else if (cBVAV.NumZonesHeated > cBVAV.NumZonesCooled) {
+                cbvav.HeatCoolMode = HeatingMode;
+            } else if (cbvav.NumZonesHeated > cbvav.NumZonesCooled) {
                 if (QZoneReqHeat > 0.0) {
-                    cBVAV.HeatCoolMode = HeatingMode;
+                    cbvav.HeatCoolMode = HeatingMode;
                 } else if (QZoneReqCool < 0.0) {
-                    cBVAV.HeatCoolMode = CoolingMode;
+                    cbvav.HeatCoolMode = CoolingMode;
                 }
-            } else if (cBVAV.NumZonesHeated < cBVAV.NumZonesCooled) {
+            } else if (cbvav.NumZonesHeated < cbvav.NumZonesCooled) {
                 if (QZoneReqCool < 0.0) {
-                    cBVAV.HeatCoolMode = CoolingMode;
+                    cbvav.HeatCoolMode = CoolingMode;
                 } else if (QZoneReqHeat > 0.0) {
-                    cBVAV.HeatCoolMode = HeatingMode;
+                    cbvav.HeatCoolMode = HeatingMode;
                 }
             } else {
                 if (QZoneReqCool < 0.0) {
-                    cBVAV.HeatCoolMode = CoolingMode;
+                    cbvav.HeatCoolMode = CoolingMode;
                 } else if (QZoneReqHeat > 0.0) {
-                    cBVAV.HeatCoolMode = HeatingMode;
+                    cbvav.HeatCoolMode = HeatingMode;
                 }
             }
             break;
@@ -3524,10 +3437,10 @@ namespace HVACUnitaryBypassVAV {
         }
         }
 
-        if (cBVAV.LastMode != cBVAV.HeatCoolMode) {
-            cBVAV.changeOverTimer = thisTime + cBVAV.minModeChangeTime;
-            cBVAV.LastMode = cBVAV.HeatCoolMode;
-            cBVAV.modeChanged = true;
+        if (cbvav.LastMode != cbvav.HeatCoolMode) {
+            cbvav.changeOverTimer = thisTime + cbvav.minModeChangeTime;
+            cbvav.LastMode = cbvav.HeatCoolMode;
+            cbvav.modeChanged = true;
         }
     }
 
@@ -3556,28 +3469,29 @@ namespace HVACUnitaryBypassVAV {
         Real64 SupplyAirTempToHeatSetPt; // Supply air temperature required to reach the heating setpoint [C]
         Real64 SupplyAirTempToCoolSetPt; // Supply air temperature required to reach the cooling setpoint [C]
 
-        auto &cBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNumber);
+        auto &s_node = state.dataLoopNodes;
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNumber);
 
-        Real64 DXCoolCoilInletTemp = state.dataLoopNodes->Node(cBVAV.DXCoilInletNode).Temp;
-        Real64 OutAirTemp = state.dataLoopNodes->Node(cBVAV.AirOutNode).Temp;
-        Real64 OutAirHumRat = state.dataLoopNodes->Node(cBVAV.AirOutNode).HumRat;
+        Real64 DXCoolCoilInletTemp = s_node->Node(cbvav.CoolCoilAirInletNode).Temp;
+        Real64 OutAirTemp = s_node->Node(cbvav.AirOutNode).Temp;
+        Real64 OutAirHumRat = s_node->Node(cbvav.AirOutNode).HumRat;
 
-        if (cBVAV.HeatCoolMode == CoolingMode) { // Cooling required
+        if (cbvav.HeatCoolMode == CoolingMode) { // Cooling required
             CalcSetPointTempTarget = 99999.0;
-        } else if (cBVAV.HeatCoolMode == HeatingMode) { // Heating required
+        } else if (cbvav.HeatCoolMode == HeatingMode) { // Heating required
             CalcSetPointTempTarget = -99999.0;
         }
         Real64 TSupplyToHeatSetPtMax = -99999.0; // Maximum of the supply air temperatures required to reach the heating setpoint [C]
         Real64 TSupplyToCoolSetPtMin = 99999.0;  // Minimum of the supply air temperatures required to reach the cooling setpoint [C]
 
-        for (int ZoneNum = 1; ZoneNum <= cBVAV.NumControlledZones; ++ZoneNum) {
-            int ZoneNodeNum = cBVAV.ControlledZoneNodeNum(ZoneNum);
-            int BoxOutletNodeNum = cBVAV.CBVAVBoxOutletNode(ZoneNum);
-            if ((cBVAV.ZoneSequenceCoolingNum(ZoneNum) > 0) && (cBVAV.ZoneSequenceHeatingNum(ZoneNum) > 0)) {
-                QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum))
-                                   .SequencedOutputRequiredToCoolingSP(cBVAV.ZoneSequenceCoolingNum(ZoneNum));
-                QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum))
-                                   .SequencedOutputRequiredToHeatingSP(cBVAV.ZoneSequenceHeatingNum(ZoneNum));
+        for (int ZoneNum = 1; ZoneNum <= cbvav.NumControlledZones; ++ZoneNum) {
+            int ZoneNodeNum = cbvav.ControlledZoneNodeNum(ZoneNum);
+            int BoxOutletNodeNum = cbvav.CBVAVBoxOutletNode(ZoneNum);
+            if ((cbvav.ZoneSequenceCoolingNum(ZoneNum) > 0) && (cbvav.ZoneSequenceHeatingNum(ZoneNum) > 0)) {
+                QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum))
+                                   .SequencedOutputRequiredToCoolingSP(cbvav.ZoneSequenceCoolingNum(ZoneNum));
+                QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum))
+                                   .SequencedOutputRequiredToHeatingSP(cbvav.ZoneSequenceHeatingNum(ZoneNum));
                 if (QToHeatSetPt > 0.0 && QToCoolSetPt > 0.0) {
                     ZoneLoad = QToHeatSetPt;
                 } else if (QToHeatSetPt < 0.0 && QToCoolSetPt < 0.0) {
@@ -3586,44 +3500,44 @@ namespace HVACUnitaryBypassVAV {
                     ZoneLoad = 0.0;
                 }
             } else {
-                ZoneLoad = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum)).RemainingOutputRequired;
-                QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum)).OutputRequiredToCoolingSP;
-                QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum)).OutputRequiredToHeatingSP;
+                ZoneLoad = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum)).RemainingOutputRequired;
+                QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum)).OutputRequiredToCoolingSP;
+                QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum)).OutputRequiredToHeatingSP;
             }
 
             Real64 CpSupplyAir = Psychrometrics::PsyCpAirFnW(OutAirHumRat);
 
             // Find the supply air temperature that will force the box to full flow
             if (BoxOutletNodeNum > 0) {
-                if (state.dataLoopNodes->Node(BoxOutletNodeNum).MassFlowRateMax == 0.0) {
-                    SupplyAirTemp = state.dataLoopNodes->Node(ZoneNodeNum).Temp;
+                if (s_node->Node(BoxOutletNodeNum).MassFlowRateMax == 0.0) {
+                    SupplyAirTemp = s_node->Node(ZoneNodeNum).Temp;
                 } else {
                     // The target supply air temperature is based on current zone temp and load and max box flow rate
-                    SupplyAirTemp = state.dataLoopNodes->Node(ZoneNodeNum).Temp +
-                                    ZoneLoad / (CpSupplyAir * state.dataLoopNodes->Node(BoxOutletNodeNum).MassFlowRateMax);
+                    SupplyAirTemp = s_node->Node(ZoneNodeNum).Temp +
+                                    ZoneLoad / (CpSupplyAir * s_node->Node(BoxOutletNodeNum).MassFlowRateMax);
                 }
             } else {
-                SupplyAirTemp = state.dataLoopNodes->Node(ZoneNodeNum).Temp;
+                SupplyAirTemp = s_node->Node(ZoneNodeNum).Temp;
             }
 
             //     Save the MIN (cooling) or MAX (heating) temperature for coil control
             //     One box will always operate at maximum damper position minimizing overall system energy use
-            if (cBVAV.HeatCoolMode == CoolingMode) {
+            if (cbvav.HeatCoolMode == CoolingMode) {
                 CalcSetPointTempTarget = min(SupplyAirTemp, CalcSetPointTempTarget);
-            } else if (cBVAV.HeatCoolMode == HeatingMode) {
+            } else if (cbvav.HeatCoolMode == HeatingMode) {
                 CalcSetPointTempTarget = max(SupplyAirTemp, CalcSetPointTempTarget);
             } else {
                 //       Should use CpAirAtCoolSetPoint or CpAirAtHeatSetPoint here?
                 //       If so, use ZoneThermostatSetPointLo(ZoneNum) and ZoneThermostatSetPointHi(ZoneNum)
                 //       along with the zone humidity ratio
-                if (state.dataLoopNodes->Node(BoxOutletNodeNum).MassFlowRateMax == 0.0) {
-                    SupplyAirTempToHeatSetPt = state.dataLoopNodes->Node(ZoneNodeNum).Temp;
-                    SupplyAirTempToCoolSetPt = state.dataLoopNodes->Node(ZoneNodeNum).Temp;
+                if (s_node->Node(BoxOutletNodeNum).MassFlowRateMax == 0.0) {
+                    SupplyAirTempToHeatSetPt = s_node->Node(ZoneNodeNum).Temp;
+                    SupplyAirTempToCoolSetPt = s_node->Node(ZoneNodeNum).Temp;
                 } else {
-                    SupplyAirTempToHeatSetPt = state.dataLoopNodes->Node(ZoneNodeNum).Temp +
-                                               QToHeatSetPt / (CpSupplyAir * state.dataLoopNodes->Node(BoxOutletNodeNum).MassFlowRateMax);
-                    SupplyAirTempToCoolSetPt = state.dataLoopNodes->Node(ZoneNodeNum).Temp +
-                                               QToCoolSetPt / (CpSupplyAir * state.dataLoopNodes->Node(BoxOutletNodeNum).MassFlowRateMax);
+                    SupplyAirTempToHeatSetPt = s_node->Node(ZoneNodeNum).Temp +
+                                               QToHeatSetPt / (CpSupplyAir * s_node->Node(BoxOutletNodeNum).MassFlowRateMax);
+                    SupplyAirTempToCoolSetPt = s_node->Node(ZoneNodeNum).Temp +
+                                               QToCoolSetPt / (CpSupplyAir * s_node->Node(BoxOutletNodeNum).MassFlowRateMax);
                 }
                 TSupplyToHeatSetPtMax = max(SupplyAirTempToHeatSetPt, TSupplyToHeatSetPtMax);
                 TSupplyToCoolSetPtMin = min(SupplyAirTempToCoolSetPt, TSupplyToCoolSetPtMin);
@@ -3631,8 +3545,8 @@ namespace HVACUnitaryBypassVAV {
         }
 
         //   Account for floating condition where cooling/heating is required to avoid overshooting setpoint
-        if (cBVAV.HeatCoolMode == 0) {
-            if (cBVAV.fanOp == HVAC::FanOp::Continuous) {
+        if (cbvav.HeatCoolMode == 0) {
+            if (cbvav.fanOp == HVAC::FanOp::Continuous) {
                 if (OutAirTemp > TSupplyToCoolSetPtMin) {
                     CalcSetPointTempTarget = TSupplyToCoolSetPtMin;
                 } else if (OutAirTemp < TSupplyToHeatSetPtMax) {
@@ -3641,19 +3555,19 @@ namespace HVACUnitaryBypassVAV {
                     CalcSetPointTempTarget = OutAirTemp;
                 }
             } else { // Reset setpoint to inlet air temp if unit is OFF and in cycling fan mode
-                CalcSetPointTempTarget = state.dataLoopNodes->Node(cBVAV.AirInNode).Temp;
+                CalcSetPointTempTarget = s_node->Node(cbvav.AirInNode).Temp;
             }
             //   Reset cooling/heating mode to OFF if mixed air inlet temperature is below/above setpoint temperature.
             //   HeatCoolMode = 0 for OFF, 1 for cooling, 2 for heating
-        } else if (cBVAV.HeatCoolMode == CoolingMode) {
+        } else if (cbvav.HeatCoolMode == CoolingMode) {
             if (DXCoolCoilInletTemp < CalcSetPointTempTarget) CalcSetPointTempTarget = DXCoolCoilInletTemp;
-        } else if (cBVAV.HeatCoolMode == HeatingMode) {
+        } else if (cbvav.HeatCoolMode == HeatingMode) {
             if (DXCoolCoilInletTemp > CalcSetPointTempTarget) CalcSetPointTempTarget = DXCoolCoilInletTemp;
         }
 
         //   Limit outlet node temperature to MAX/MIN specified in input
-        if (CalcSetPointTempTarget < cBVAV.MinLATCooling) CalcSetPointTempTarget = cBVAV.MinLATCooling;
-        if (CalcSetPointTempTarget > cBVAV.MaxLATHeating) CalcSetPointTempTarget = cBVAV.MaxLATHeating;
+        if (CalcSetPointTempTarget < cbvav.MinLATCooling) CalcSetPointTempTarget = cbvav.MinLATCooling;
+        if (CalcSetPointTempTarget > cbvav.MaxLATHeating) CalcSetPointTempTarget = cbvav.MaxLATHeating;
 
         return CalcSetPointTempTarget;
     }
@@ -3676,26 +3590,27 @@ namespace HVACUnitaryBypassVAV {
         Real64 ZoneMassFlow; // Zone mass flow rate required to meet zone load [kg/s]
         Real64 ZoneLoad;     // Zone load calculated by ZoneTempPredictor [W]
 
-        auto &cBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &s_node = state.dataLoopNodes;
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
-        int InletNode = cBVAV.AirInNode;                     // Inlet node number for CBVAVNum
-        int OutletNode = cBVAV.AirOutNode;                   // Outlet node number for CBVAVNum
-        int MixerMixedAirNode = cBVAV.MixerMixedAirNode;     // Mixed air node number in OA mixer
-        int MixerOutsideAirNode = cBVAV.MixerOutsideAirNode; // Outside air node number in OA mixer
-        int MixerReliefAirNode = cBVAV.MixerReliefAirNode;   // Relief air node number in OA mixer
-        int MixerInletAirNode = cBVAV.MixerInletAirNode;     // Inlet air node number in OA mixer
+        int InletNode = cbvav.AirInNode;                     // Inlet node number for CBVAVNum
+        int OutletNode = cbvav.AirOutNode;                   // Outlet node number for CBVAVNum
+        int MixerMixedAirNode = cbvav.MixerMixedAirNode;     // Mixed air node number in OA mixer
+        int MixerOutsideAirNode = cbvav.MixerOutsideAirNode; // Outside air node number in OA mixer
+        int MixerReliefAirNode = cbvav.MixerReliefAirNode;   // Relief air node number in OA mixer
+        int MixerInletAirNode = cbvav.MixerInletAirNode;     // Inlet air node number in OA mixer
 
         Real64 SystemMassFlow = 0.0; // System mass flow rate required for all zones [kg/s]
-        Real64 CpSupplyAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(OutletNode).HumRat); // Specific heat of outlet air [J/kg-K]
+        Real64 CpSupplyAir = Psychrometrics::PsyCpAirFnW(s_node->Node(OutletNode).HumRat); // Specific heat of outlet air [J/kg-K]
         // Determine zone air flow
-        for (int ZoneNum = 1; ZoneNum <= cBVAV.NumControlledZones; ++ZoneNum) {
-            int ZoneNodeNum = cBVAV.ControlledZoneNodeNum(ZoneNum);
-            int BoxOutletNodeNum = cBVAV.CBVAVBoxOutletNode(ZoneNum); // Zone supply air inlet node number
-            if ((cBVAV.ZoneSequenceCoolingNum(ZoneNum) > 0) && (cBVAV.ZoneSequenceHeatingNum(ZoneNum) > 0)) {
-                Real64 QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum))
-                                          .SequencedOutputRequiredToCoolingSP(cBVAV.ZoneSequenceCoolingNum(ZoneNum));
-                Real64 QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum))
-                                          .SequencedOutputRequiredToHeatingSP(cBVAV.ZoneSequenceHeatingNum(ZoneNum));
+        for (int ZoneNum = 1; ZoneNum <= cbvav.NumControlledZones; ++ZoneNum) {
+            int ZoneNodeNum = cbvav.ControlledZoneNodeNum(ZoneNum);
+            int BoxOutletNodeNum = cbvav.CBVAVBoxOutletNode(ZoneNum); // Zone supply air inlet node number
+            if ((cbvav.ZoneSequenceCoolingNum(ZoneNum) > 0) && (cbvav.ZoneSequenceHeatingNum(ZoneNum) > 0)) {
+                Real64 QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum))
+                                          .SequencedOutputRequiredToCoolingSP(cbvav.ZoneSequenceCoolingNum(ZoneNum));
+                Real64 QToHeatSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum))
+                                          .SequencedOutputRequiredToHeatingSP(cbvav.ZoneSequenceHeatingNum(ZoneNum));
                 if (QToHeatSetPt > 0.0 && QToCoolSetPt > 0.0) {
                     ZoneLoad = QToHeatSetPt;
                 } else if (QToHeatSetPt < 0.0 && QToCoolSetPt < 0.0) {
@@ -3704,10 +3619,10 @@ namespace HVACUnitaryBypassVAV {
                     ZoneLoad = 0.0;
                 }
             } else {
-                ZoneLoad = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cBVAV.ControlledZoneNum(ZoneNum)).RemainingOutputRequired;
+                ZoneLoad = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(cbvav.ControlledZoneNum(ZoneNum)).RemainingOutputRequired;
             }
-            Real64 CpZoneAir = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(ZoneNodeNum).HumRat);
-            Real64 DeltaCpTemp = CpSupplyAir * state.dataLoopNodes->Node(OutletNode).Temp - CpZoneAir * state.dataLoopNodes->Node(ZoneNodeNum).Temp;
+            Real64 CpZoneAir = Psychrometrics::PsyCpAirFnW(s_node->Node(ZoneNodeNum).HumRat);
+            Real64 DeltaCpTemp = CpSupplyAir * s_node->Node(OutletNode).Temp - CpZoneAir * s_node->Node(ZoneNodeNum).Temp;
 
             // Need to check DeltaCpTemp and ensure that it is not zero
             if (DeltaCpTemp != 0.0) { // .AND. .NOT. CurDeadBandOrSetback(ZoneNum))THEN
@@ -3716,32 +3631,32 @@ namespace HVACUnitaryBypassVAV {
                 //     reset to 0 so we don't add in the last zone's mass flow rate
                 ZoneMassFlow = 0.0;
             }
-            SystemMassFlow += max(state.dataLoopNodes->Node(BoxOutletNodeNum).MassFlowRateMin,
-                                  min(ZoneMassFlow, state.dataLoopNodes->Node(BoxOutletNodeNum).MassFlowRateMax));
+            SystemMassFlow += max(s_node->Node(BoxOutletNodeNum).MassFlowRateMin,
+                                  min(ZoneMassFlow, s_node->Node(BoxOutletNodeNum).MassFlowRateMax));
         }
 
         Real64 AverageUnitMassFlow = state.dataHVACUnitaryBypassVAV->CompOnMassFlow;
         Real64 AverageOAMassFlow = state.dataHVACUnitaryBypassVAV->OACompOnMassFlow;
         state.dataHVACUnitaryBypassVAV->FanSpeedRatio = state.dataHVACUnitaryBypassVAV->CompOnFlowRatio;
 
-        state.dataLoopNodes->Node(MixerInletAirNode) = state.dataLoopNodes->Node(InletNode);
+        s_node->Node(MixerInletAirNode) = s_node->Node(InletNode);
 
-        state.dataLoopNodes->Node(MixerMixedAirNode).MassFlowRateMin = 0.0;
+        s_node->Node(MixerMixedAirNode).MassFlowRateMin = 0.0;
 
-        if (cBVAV.availSched->getCurrentVal() == 0.0 || AverageUnitMassFlow == 0.0) {
-            state.dataLoopNodes->Node(InletNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(MixerReliefAirNode).MassFlowRate = 0.0;
+        if (cbvav.availSched->getCurrentVal() == 0.0 || AverageUnitMassFlow == 0.0) {
+            s_node->Node(InletNode).MassFlowRate = 0.0;
+            s_node->Node(MixerOutsideAirNode).MassFlowRate = 0.0;
+            s_node->Node(MixerReliefAirNode).MassFlowRate = 0.0;
             OnOffAirFlowRatio = 0.0;
             state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction = 0.0;
         } else {
-            state.dataLoopNodes->Node(MixerInletAirNode).MassFlowRate = AverageUnitMassFlow;
-            state.dataLoopNodes->Node(MixerOutsideAirNode).MassFlowRate = AverageOAMassFlow;
-            state.dataLoopNodes->Node(MixerReliefAirNode).MassFlowRate = AverageOAMassFlow;
+            s_node->Node(MixerInletAirNode).MassFlowRate = AverageUnitMassFlow;
+            s_node->Node(MixerOutsideAirNode).MassFlowRate = AverageOAMassFlow;
+            s_node->Node(MixerReliefAirNode).MassFlowRate = AverageOAMassFlow;
             OnOffAirFlowRatio = 1.0;
             Real64 boxOutletNodeFlow = 0.0;
-            for (int i = 1; i <= cBVAV.NumControlledZones; ++i) {
-                boxOutletNodeFlow += state.dataLoopNodes->Node(cBVAV.CBVAVBoxOutletNode(i)).MassFlowRate;
+            for (int i = 1; i <= cbvav.NumControlledZones; ++i) {
+                boxOutletNodeFlow += s_node->Node(cbvav.CBVAVBoxOutletNode(i)).MassFlowRate;
             }
             state.dataHVACUnitaryBypassVAV->BypassDuctFlowFraction = max(0.0, 1.0 - (boxOutletNodeFlow / AverageUnitMassFlow));
         }
@@ -3757,21 +3672,21 @@ namespace HVACUnitaryBypassVAV {
         // PURPOSE OF THIS SUBROUTINE:
         // Fills some of the report variables for the changeover-bypass VAV system
 
-        auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
         Real64 ReportingConstant = state.dataHVACGlobal->TimeStepSysSec;
 
-        thisCBVAV.TotCoolEnergy = thisCBVAV.TotCoolEnergyRate * ReportingConstant;
-        thisCBVAV.TotHeatEnergy = thisCBVAV.TotHeatEnergyRate * ReportingConstant;
-        thisCBVAV.SensCoolEnergy = thisCBVAV.SensCoolEnergyRate * ReportingConstant;
-        thisCBVAV.SensHeatEnergy = thisCBVAV.SensHeatEnergyRate * ReportingConstant;
-        thisCBVAV.LatCoolEnergy = thisCBVAV.LatCoolEnergyRate * ReportingConstant;
-        thisCBVAV.LatHeatEnergy = thisCBVAV.LatHeatEnergyRate * ReportingConstant;
-        thisCBVAV.ElecConsumption = thisCBVAV.ElecPower * ReportingConstant;
+        cbvav.TotCoolEnergy = cbvav.TotCoolEnergyRate * ReportingConstant;
+        cbvav.TotHeatEnergy = cbvav.TotHeatEnergyRate * ReportingConstant;
+        cbvav.SensCoolEnergy = cbvav.SensCoolEnergyRate * ReportingConstant;
+        cbvav.SensHeatEnergy = cbvav.SensHeatEnergyRate * ReportingConstant;
+        cbvav.LatCoolEnergy = cbvav.LatCoolEnergyRate * ReportingConstant;
+        cbvav.LatHeatEnergy = cbvav.LatHeatEnergyRate * ReportingConstant;
+        cbvav.ElecConsumption = cbvav.ElecPower * ReportingConstant;
 
-        if (thisCBVAV.FirstPass) {
+        if (cbvav.FirstPass) {
             if (!state.dataGlobal->SysSizingCalc) {
-                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, state.dataSize->CurSysNum, thisCBVAV.FirstPass);
+                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, state.dataSize->CurSysNum, cbvav.FirstPass);
             }
         }
 
@@ -3811,33 +3726,33 @@ namespace HVACUnitaryBypassVAV {
 
         Real64 QCoilActual = 0.0; // actual heating load met
 
-        auto &thisCBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
 
         if (HeatCoilLoad > HVAC::SmallLoad) {
-            switch (thisCBVAV.HeatCoilType) {
+            switch (cbvav.heatCoilType) {
             case HVAC::CoilType::HeatingGasOrOtherFuel:
             case HVAC::CoilType::HeatingElectric: {
                 HeatingCoils::SimulateHeatingCoilComponents(
-                    state, thisCBVAV.HeatCoilName, FirstHVACIteration, HeatCoilLoad, thisCBVAV.HeatCoilIndex, QCoilActual, false, fanOp);
+                    state, cbvav.HeatCoilNum, FirstHVACIteration, HeatCoilLoad, QCoilActual, false, fanOp);
             } break;
             case HVAC::CoilType::HeatingWater: {
                 // simulate the heating coil at maximum hot water flow rate
-                MaxHotWaterFlow = thisCBVAV.MaxHeatCoilFluidFlow;
-                PlantUtilities::SetComponentFlowRate(state, MaxHotWaterFlow, thisCBVAV.CoilControlNode, thisCBVAV.CoilOutletNode, thisCBVAV.plantLoc);
+                MaxHotWaterFlow = cbvav.MaxHeatCoilFluidFlow;
+                PlantUtilities::SetComponentFlowRate(state, MaxHotWaterFlow, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode, cbvav.HeatCoilPlantLoc);
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, thisCBVAV.HeatCoilName, FirstHVACIteration, thisCBVAV.HeatCoilIndex, QCoilActual, fanOp);
+                    state, cbvav.HeatCoilNum, FirstHVACIteration, QCoilActual, fanOp);
                 if (QCoilActual > (HeatCoilLoad + HVAC::SmallLoad)) {
                     // control water flow to obtain output matching HeatCoilLoad
                     int SolFlag = 0;
                     MinWaterFlow = 0.0;
                     auto f = [&state, CBVAVNum, FirstHVACIteration, HeatCoilLoad](Real64 const HWFlow) {
-                        auto &thiscBVAV = state.dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum);
+                        auto &cbvav = state.dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum);
                         Real64 QCoilActual = HeatCoilLoad;
                         Real64 mdot = HWFlow;
-                        PlantUtilities::SetComponentFlowRate(state, mdot, thiscBVAV.CoilControlNode, thiscBVAV.CoilOutletNode, thiscBVAV.plantLoc);
+                        PlantUtilities::SetComponentFlowRate(state, mdot, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode, cbvav.HeatCoilPlantLoc);
                         // simulate the hot water supplemental heating coil
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, thiscBVAV.HeatCoilName, FirstHVACIteration, thiscBVAV.HeatCoilIndex, QCoilActual, thiscBVAV.fanOp);
+                            state, cbvav.HeatCoilNum, FirstHVACIteration, QCoilActual, cbvav.fanOp);
                         if (HeatCoilLoad != 0.0) {
                             return (QCoilActual - HeatCoilLoad) / HeatCoilLoad;
                         } else { // Autodesk:Return Condition added to assure return value is set
@@ -3846,10 +3761,10 @@ namespace HVACUnitaryBypassVAV {
                     };
                     General::SolveRoot(state, ErrTolerance, SolveMaxIter, SolFlag, HotWaterMdot, f, MinWaterFlow, MaxHotWaterFlow);
                     if (SolFlag == -1) {
-                        if (thisCBVAV.HotWaterCoilMaxIterIndex == 0) {
+                        if (cbvav.HotWaterCoilMaxIterIndex == 0) {
                             ShowWarningMessage(
                                 state,
-                                format("CalcNonDXHeatingCoils: Hot water coil control failed for {}=\"{}\"", thisCBVAV.UnitType, thisCBVAV.Name));
+                                format("CalcNonDXHeatingCoils: Hot water coil control failed for {}=\"{}\"", cbvav.UnitType, cbvav.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, format("  Iteration limit [{}] exceeded in calculating hot water mass flow rate", SolveMaxIter));
                         }
@@ -3857,15 +3772,15 @@ namespace HVACUnitaryBypassVAV {
                             state,
                             format("CalcNonDXHeatingCoils: Hot water coil control failed (iteration limit [{}]) for {}=\"{}",
                                    SolveMaxIter,
-                                   thisCBVAV.UnitType,
-                                   thisCBVAV.Name),
-                            thisCBVAV.HotWaterCoilMaxIterIndex);
+                                   cbvav.UnitType,
+                                   cbvav.Name),
+                            cbvav.HotWaterCoilMaxIterIndex);
                     } else if (SolFlag == -2) {
-                        if (thisCBVAV.HotWaterCoilMaxIterIndex2 == 0) {
+                        if (cbvav.HotWaterCoilMaxIterIndex2 == 0) {
                             ShowWarningMessage(state,
                                                format("CalcNonDXHeatingCoils: Hot water coil control failed (maximum flow limits) for {}=\"{}\"",
-                                                      thisCBVAV.UnitType,
-                                                      thisCBVAV.Name));
+                                                      cbvav.UnitType,
+                                                      cbvav.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, "...Bad hot water maximum flow rate limits");
                             ShowContinueError(state, format("...Given minimum water flow rate={:.3R} kg/s", MinWaterFlow));
@@ -3873,8 +3788,8 @@ namespace HVACUnitaryBypassVAV {
                         }
                         ShowRecurringWarningErrorAtEnd(state,
                                                        "CalcNonDXHeatingCoils: Hot water coil control failed (flow limits) for " +
-                                                           thisCBVAV.UnitType + "=\"" + thisCBVAV.Name + "\"",
-                                                       thisCBVAV.HotWaterCoilMaxIterIndex2,
+                                                           cbvav.UnitType + "=\"" + cbvav.Name + "\"",
+                                                       cbvav.HotWaterCoilMaxIterIndex2,
                                                        MaxHotWaterFlow,
                                                        MinWaterFlow,
                                                        _,
@@ -3885,41 +3800,41 @@ namespace HVACUnitaryBypassVAV {
                     QCoilActual = HeatCoilLoad;
                     // simulate the hot water heating coil
                     WaterCoils::SimulateWaterCoilComponents(
-                        state, thisCBVAV.HeatCoilName, FirstHVACIteration, thisCBVAV.HeatCoilIndex, QCoilActual, fanOp);
+                        state, cbvav.HeatCoilNum, FirstHVACIteration, QCoilActual, fanOp);
                 }
             } break;
             case HVAC::CoilType::HeatingSteam: {
-                mdot = thisCBVAV.MaxHeatCoilFluidFlow;
-                PlantUtilities::SetComponentFlowRate(state, mdot, thisCBVAV.CoilControlNode, thisCBVAV.CoilOutletNode, thisCBVAV.plantLoc);
+                mdot = cbvav.MaxHeatCoilFluidFlow;
+                PlantUtilities::SetComponentFlowRate(state, mdot, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode, cbvav.HeatCoilPlantLoc);
 
                 // simulate the steam heating coil
                 SteamCoils::SimulateSteamCoilComponents(
-                    state, thisCBVAV.HeatCoilName, FirstHVACIteration, thisCBVAV.HeatCoilIndex, HeatCoilLoad, QCoilActual, fanOp);
+                    state, cbvav.HeatCoilNum, FirstHVACIteration, HeatCoilLoad, QCoilActual, fanOp);
             } break;
             default:
                 break;
             }
         } else {
-            switch (thisCBVAV.HeatCoilType) {
+            switch (cbvav.heatCoilType) {
             case HVAC::CoilType::HeatingGasOrOtherFuel:
             case HVAC::CoilType::HeatingElectric: {
                 HeatingCoils::SimulateHeatingCoilComponents(
-                    state, thisCBVAV.HeatCoilName, FirstHVACIteration, HeatCoilLoad, thisCBVAV.HeatCoilIndex, QCoilActual, false, fanOp);
+                    state, cbvav.HeatCoilNum, FirstHVACIteration, HeatCoilLoad, QCoilActual, false, fanOp);
             } break;
             case HVAC::CoilType::HeatingWater: {
                 mdot = 0.0;
-                PlantUtilities::SetComponentFlowRate(state, mdot, thisCBVAV.CoilControlNode, thisCBVAV.CoilOutletNode, thisCBVAV.plantLoc);
+                PlantUtilities::SetComponentFlowRate(state, mdot, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode, cbvav.HeatCoilPlantLoc);
                 QCoilActual = HeatCoilLoad;
                 // simulate the hot water heating coil
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, thisCBVAV.HeatCoilName, FirstHVACIteration, thisCBVAV.HeatCoilIndex, QCoilActual, fanOp);
+                    state, cbvav.HeatCoilNum, FirstHVACIteration, QCoilActual, fanOp);
             } break;
             case HVAC::CoilType::HeatingSteam: {
                 mdot = 0.0;
-                PlantUtilities::SetComponentFlowRate(state, mdot, thisCBVAV.CoilControlNode, thisCBVAV.CoilOutletNode, thisCBVAV.plantLoc);
+                PlantUtilities::SetComponentFlowRate(state, mdot, cbvav.HeatCoilControlNode, cbvav.HeatCoilFluidOutletNode, cbvav.HeatCoilPlantLoc);
                 // simulate the steam heating coil
                 SteamCoils::SimulateSteamCoilComponents(
-                    state, thisCBVAV.HeatCoilName, FirstHVACIteration, thisCBVAV.HeatCoilIndex, HeatCoilLoad, QCoilActual, fanOp);
+                    state, cbvav.HeatCoilNum, FirstHVACIteration, HeatCoilLoad, QCoilActual, fanOp);
             } break;
             default:
                 break;
diff --git a/src/EnergyPlus/HVACUnitaryBypassVAV.hh b/src/EnergyPlus/HVACUnitaryBypassVAV.hh
index 2ff2d4e0ef4..ebc6e2f39d4 100644
--- a/src/EnergyPlus/HVACUnitaryBypassVAV.hh
+++ b/src/EnergyPlus/HVACUnitaryBypassVAV.hh
@@ -145,18 +145,28 @@ namespace HVACUnitaryBypassVAV {
         Real64 CoolingSpeedRatio = 1.0;                    // Fan speed ratio in cooling mode
         Real64 NoHeatCoolSpeedRatio = 1.0;                 // Fan speed ratio when no cooling or heating
         bool CheckFanFlow = true;                          // Check fan volumetric flow versus system flow in init routine.
-        std::string DXCoolCoilName;                        // Name of DX cooling coil
-        HVAC::CoilType CoolCoilType = HVAC::CoilType::Invalid;
-        int CoolCoilCompIndex = 0;  // cooling coil component index number
-        int DXCoolCoilIndexNum = 0; // actual DX cooling coil index number
-        int DXHeatCoilIndexNum = 0; // actual DX heating coil index number
-        std::string HeatCoilName;   // Name of heating coil
-        HVAC::CoilType HeatCoilType = HVAC::CoilType::Invalid;
-        int HeatCoilIndex = 0;                    // DX heating coil index number
         HVAC::FanOp fanOp = HVAC::FanOp::Invalid; // mode of operation
-        int CoilControlNode = 0;                  // heating coil hot water or steam inlet node
-        int CoilOutletNode = 0;                   // outlet node for hot water and steam coil
-        PlantLocation plantLoc;                   // plant loop component location object for water heating coil
+
+        std::string CoolCoilName;                        // Name of DX cooling coil
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;
+        int CoolCoilNum = 0;  // cooling coil component index number
+        int CoolCoilAirInletNode = 0;                                 // Inlet node number of DX cooling coil
+        int CoolCoilAirOutletNode = 0;                                // Outlet node number of DX cooling coil
+
+        // For HXAssisted coils, these are for the "child" embedded coil object while the variables above are for the parent object
+        std::string childCoolCoilName;
+        HVAC::CoilType childCoolCoilType = HVAC::CoilType::Invalid;
+        int childCoolCoilNum = 0;
+      
+        std::string HeatCoilName;   // Name of heating coil
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;
+        int HeatCoilNum = 0;                    // DX heating coil index number
+        int HeatCoilAirInletNode = 0;
+        int HeatCoilAirOutletNode = 0;
+        PlantLocation HeatCoilPlantLoc = {};                   // plant loop component location object for water heating coil
+        int HeatCoilControlNode = 0;                  // heating coil hot water or steam inlet node
+        int HeatCoilFluidOutletNode = 0;                   // outlet node for hot water and steam coil
+      
         int HotWaterCoilMaxIterIndex = 0;         // Index to recurring warning message
         int HotWaterCoilMaxIterIndex2 = 0;        // Index to recurring warning message
         Real64 MaxHeatCoilFluidFlow = 0.0;        // water or steam mass flow rate for heating coil [kg/s]
@@ -197,10 +207,6 @@ namespace HVACUnitaryBypassVAV {
         int NumZonesHeated = 0;                                       // Number of zones requesting heating
         int PLRMaxIter = 0;                                           // Counter for recurring warning message
         int PLRMaxIterIndex = 0;                                      // Index to recurring warning message
-        int DXCoilInletNode = 0;                                      // Inlet node number of DX cooling coil
-        int DXCoilOutletNode = 0;                                     // Outlet node number of DX cooling coil
-        int HeatingCoilInletNode = 0;                                 // Inlet node of heating coil
-        int HeatingCoilOutletNode = 0;                                // Outlet node of heating coil
         int FanInletNodeNum = 0;                                      // fan inlet node number
         Real64 OutletTempSetPoint = 0.0;                              // Oulet node temperature setpoint [C]
         Real64 CoilTempSetPoint = 0.0;                                // Coil oulet node temperature setpoint (inc. fan heat) [C]
@@ -334,7 +340,7 @@ struct HVACUnitaryBypassVAVData : BaseGlobalStruct
     Real64 TempSteamIn = 100.0;          // steam coil steam inlet temperature
     Array1D_bool CheckEquipName;
 
-    EPVector<HVACUnitaryBypassVAV::CBVAVData> CBVAV;
+    EPVector<HVACUnitaryBypassVAV::CBVAVData> CBVAVs;
     bool GetInputFlag = true; // Flag set to make sure you get input once
 
     bool MyOneTimeFlag = true; // Initialization flag
@@ -353,7 +359,7 @@ struct HVACUnitaryBypassVAVData : BaseGlobalStruct
 
     void clear_state() override
     {
-        this->CBVAV.deallocate();
+        this->CBVAVs.deallocate();
         this->NumCBVAV = 0;
         this->CompOnMassFlow = 0.0;
         this->OACompOnMassFlow = 0.0;
diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc
index fb681eac3a4..5042a159d5c 100644
--- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc
+++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc
@@ -225,9 +225,9 @@ void SimulateVRF(EnergyPlusData &state,
     // the entry number in the terminal unit list (which item in the terminal unit list, e.g. second in list)
     IndexToTUInTUList = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).IndexToTUInTUList;
     // index to cooling coil (coil is optional but at least one must be present)
-    DXCoolingCoilIndex = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).CoolCoilIndex;
+    DXCoolingCoilIndex = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).CoolCoilNum;
     // index to heating coil (coil is optional but at least one must be present)
-    DXHeatingCoilIndex = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).HeatCoilIndex;
+    DXHeatingCoilIndex = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).HeatCoilNum;
     QZnReq = 0.0;
 
     // Initialize terminal unit
@@ -544,8 +544,8 @@ void CalcVRFCondenser(EnergyPlusData &state, int const VRFCond)
     // loop through TU's and calculate average inlet conditions for active coils
     for (NumTU = 1; NumTU <= NumTUInList; ++NumTU) {
         int TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-        int CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex;
-        int HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex;
+        int CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum;
+        int HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilNum;
         TUParasiticPower +=
             state.dataHVACVarRefFlow->VRFTU(TUIndex).ParasiticCoolElecPower + state.dataHVACVarRefFlow->VRFTU(TUIndex).ParasiticHeatElecPower;
         TUFanPower += state.dataHVACVarRefFlow->VRFTU(TUIndex).FanPower;
@@ -1372,19 +1372,13 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
     using Curve::checkCurveIsNormalizedToOne;
     using Curve::CurveValue;
     using Curve::GetCurveIndex;
-    using DXCoils::GetDXCoilIndex;
 
     using DataSizing::AutoSize;
-    using DXCoils::GetCoilCondenserInletNode;
-    using DXCoils::GetCoilTypeNum;
-    using DXCoils::GetDXCoilCapFTCurveIndex;
-    using DXCoils::GetDXCoilName;
     using DXCoils::RatedInletAirTempHeat;
     using DXCoils::RatedInletWetBulbTemp;
     using DXCoils::RatedOutdoorAirTemp;
     using DXCoils::RatedOutdoorAirTempHeat;
     using DXCoils::RatedOutdoorWetBulbTempHeat;
-    using DXCoils::SetDXCoolingCoilData;
     using MixedAir::GetOAMixerNodeNumbers;
     using NodeInputManager::GetOnlySingleNode;
     using OutAirNodeManager::CheckOutAirNodeNumber;
@@ -3230,11 +3224,6 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
     cCurrentModuleObject = "ZoneHVAC:TerminalUnit:VariableRefrigerantFlow";
     for (int VRFTUNum = 1; VRFTUNum <= state.dataHVACVarRefFlow->NumVRFTU; ++VRFTUNum) {
 
-        //     initialize local node number variables
-        int CCoilInletNodeNum = 0;
-        int CCoilOutletNodeNum = 0;
-        int HCoilInletNodeNum = 0;
-        int HCoilOutletNodeNum = 0;
         OANodeNums = 0;
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
@@ -3448,656 +3437,272 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
         }
 
         // Get DX cooling coil data
-        std::string DXCoolingCoilType = cAlphaArgs(11);
-
         errFlag = false;
-        thisVrfTU.DXCoolCoilType_Num = GetCoilTypeNum(state, DXCoolingCoilType, cAlphaArgs(12), errFlag, false);
-        if (thisVrfTU.DXCoolCoilType_Num == 0) {
+        
+        thisVrfTU.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, cAlphaArgs(11)));
+        thisVrfTU.CoolCoilName = cAlphaArgs(12);
+        
+        if (thisVrfTU.coolCoilType == HVAC::CoilType::Invalid) {
             thisVrfTU.CoolingCoilPresent = false;
             if (thisVrfTU.TUListIndex > 0 && thisVrfTU.IndexToTUInTUList > 0) {
                 state.dataHVACVarRefFlow->TerminalUnitList(thisVrfTU.TUListIndex).CoolingCoilPresent(thisVrfTU.IndexToTUInTUList) = false;
             }
+        } else if (thisVrfTU.VRFSysNum == 0) {
+            thisVrfTU.CoolingCoilPresent = false;
+            ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
+            ShowContinueError(state, format("... when checking {} \"{}\"", HVAC::coilTypeNames[(int)thisVrfTU.coolCoilType], thisVrfTU.CoolCoilName));
+            ShowContinueError(state, "... terminal unit not connected to condenser.");
+            ShowContinueError(state, "... check that terminal unit is specified in a terminal unit list object.");
+            ShowContinueError(state, "... also check that the terminal unit list name is specified in an AirConditioner:VariableRefrigerantFlow object.");
+            ErrorsFound = true;
+
         } else {
-            if (thisVrfTU.VRFSysNum > 0) {
-                if (state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).VRFAlgorithmType == AlgorithmType::FluidTCtrl) {
-                    // Algorithm Type: VRF model based on physics, applicable for Fluid Temperature Control
+            auto &vrfCondenser = state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum);
+            if (vrfCondenser.VRFAlgorithmType == AlgorithmType::FluidTCtrl) {
+                // Algorithm Type: VRF model based on physics, applicable for Fluid Temperature Control
 
-                    if (Util::SameString(HVAC::cAllCoilTypes(thisVrfTU.DXCoolCoilType_Num), HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Cooling))) {
-                        errFlag = false;
+                if (thisVrfTU.coolCoilType == HVAC::CoilType::CoolingVRFFluidTCtrl) {
+                    thisVrfTU.CoolCoilNum = DXCoils::GetCoilIndex(state, thisVrfTU.CoolCoilName);
+                    if (thisVrfTU.CoolCoilNum == 0) {
+                        thisVrfTU.CoolingCoilPresent = false;
+                        ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(12), thisVrfTU.CoolCoilName);
+                        ErrorsFound = true;
+                    } else {
                         if (thisVrfTU.TUListIndex > 0 && thisVrfTU.IndexToTUInTUList > 0) {
                             state.dataHVACVarRefFlow->TerminalUnitList(thisVrfTU.TUListIndex).coolingCoilAvailScheds(thisVrfTU.IndexToTUInTUList) =
-                                DXCoils::GetDXCoilAvailSched(state, DXCoolingCoilType, cAlphaArgs(12), errFlag);
+                                DXCoils::GetCoilAvailSched(state, thisVrfTU.CoolCoilNum);
                         }
-                        GetDXCoilIndex(
-                            state, cAlphaArgs(12), thisVrfTU.CoolCoilIndex, errFlag, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Cooling));
-                        CCoilInletNodeNum =
-                            DXCoils::GetCoilInletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Cooling), cAlphaArgs(12), errFlag);
-                        CCoilOutletNodeNum =
-                            DXCoils::GetCoilOutletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Cooling), cAlphaArgs(12), errFlag);
-                        thisVrfTU.coolCoilAirInNode = CCoilInletNodeNum;
-                        thisVrfTU.coolCoilAirOutNode = CCoilOutletNodeNum;
-
-                        if (errFlag) ShowContinueError(state, "...occurs in " + cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-
-                        if (thisVrfTU.VRFSysNum > 0) {
-                            SetDXCoolingCoilData(
-                                state, thisVrfTU.CoolCoilIndex, ErrorsFound, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserType);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.CoolCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserNodeNum);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.CoolCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATCCHeater);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.CoolCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MinOATCooling);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.CoolCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATCooling);
-
-                            state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilIndex).VRFIUPtr = VRFTUNum;
-                            state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilIndex).VRFOUPtr = thisVrfTU.VRFSysNum;
-                            state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilIndex).SupplyFanIndex = thisVrfTU.FanIndex;
-
-                            if (thisVrfTU.FanIndex > 0) {
-                                state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilIndex).RatedAirVolFlowRate(1) =
-                                    state.dataFans->fans(thisVrfTU.FanIndex)->maxAirFlowRate;
-                            } else {
-                                state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilIndex).RatedAirVolFlowRate(1) = AutoSize;
-                            }
 
+                        thisVrfTU.coolCoilAirInNode = DXCoils::GetCoilAirInletNode(state, thisVrfTU.CoolCoilNum);
+                        thisVrfTU.coolCoilAirOutNode = DXCoils::GetCoilAirOutletNode(state, thisVrfTU.CoolCoilNum);
+
+                        DXCoils::SetCoilCondenserType(state, thisVrfTU.CoolCoilNum, vrfCondenser.CondenserType);
+                        DXCoils::SetCoilCondenserInletNode(state, thisVrfTU.CoolCoilNum, vrfCondenser.CondenserNodeNum);
+                        DXCoils::SetCoilMaxOATCrankcaseHeater(state, thisVrfTU.CoolCoilNum, vrfCondenser.MaxOATCCHeater);
+                        DXCoils::SetCoilOATCoolingInfo(state, thisVrfTU.CoolCoilNum, vrfCondenser.MinOATCooling, vrfCondenser.MaxOATCooling);
+
+                        state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilNum).VRFIUPtr = VRFTUNum;
+                        state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilNum).VRFOUPtr = thisVrfTU.VRFSysNum;
+                        state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilNum).SupplyFanIndex = thisVrfTU.FanIndex;
+
+                        if (thisVrfTU.FanIndex > 0) {
+                            state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilNum).RatedAirVolFlowRate(1) =
+                                state.dataFans->fans(thisVrfTU.FanIndex)->maxAirFlowRate;
                         } else {
-                            ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                            ShowContinueError(
-                                state, "... when checking " + HVAC::cAllCoilTypes(thisVrfTU.DXCoolCoilType_Num) + " \"" + cAlphaArgs(12) + "\"");
-                            ShowContinueError(state, "... terminal unit not connected to condenser.");
-                            ShowContinueError(state, "... check that terminal unit is specified in a terminal unit list object.");
-                            ShowContinueError(state,
-                                              "... also check that the terminal unit list name is specified in an "
-                                              "AirConditioner:VariableRefrigerantFlow object.");
-                            ErrorsFound = true;
+                            state.dataDXCoils->DXCoil(thisVrfTU.CoolCoilNum).RatedAirVolFlowRate(1) = AutoSize;
                         }
-                    } else {
-                        ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                        ShowContinueError(state, "... illegal " + cAlphaFieldNames(12) + " = " + cAlphaArgs(12));
-                        ErrorsFound = true;
                     }
-
                 } else {
-                    // Algorithm Type: VRF model based on system curve
+                    ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
+                    ShowContinueError(state, "... illegal " + cAlphaFieldNames(12) + " = " + cAlphaArgs(12));
+                    ErrorsFound = true;
+                }
 
-                    if (Util::SameString(HVAC::cAllCoilTypes(thisVrfTU.DXCoolCoilType_Num), HVAC::cAllCoilTypes(HVAC::CoilVRF_Cooling))) {
+            } else { // vrfCondenser.VRFAlgorithmType == AlgorithmType::SysCurve
+                if (thisVrfTU.coolCoilType == HVAC::CoilType::CoolingVRF) {
+                    thisVrfTU.CoolCoilNum = DXCoils::GetCoilIndex(state, thisVrfTU.CoolCoilName);
+                    if (thisVrfTU.CoolCoilNum == 0) {
+                        thisVrfTU.CoolingCoilPresent = false;
+                        ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(12), thisVrfTU.CoolCoilName);
+                        ErrorsFound = true;
+                    } else {
                         if (thisVrfTU.TUListIndex > 0 && thisVrfTU.IndexToTUInTUList > 0) {
                             state.dataHVACVarRefFlow->TerminalUnitList(thisVrfTU.TUListIndex).coolingCoilAvailScheds(thisVrfTU.IndexToTUInTUList) =
-                                DXCoils::GetDXCoilAvailSched(state, DXCoolingCoilType, cAlphaArgs(12), errFlag);
+                                DXCoils::GetCoilAvailSched(state, thisVrfTU.CoolCoilNum);
                         } else {
                             thisVrfTU.CoolingCoilPresent = false;
                         }
-                        errFlag = false;
-                        GetDXCoilIndex(state, cAlphaArgs(12), thisVrfTU.CoolCoilIndex, errFlag, HVAC::cAllCoilTypes(HVAC::CoilVRF_Cooling));
-                        CCoilInletNodeNum = DXCoils::GetCoilInletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Cooling), cAlphaArgs(12), errFlag);
-                        CCoilOutletNodeNum = DXCoils::GetCoilOutletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Cooling), cAlphaArgs(12), errFlag);
-                        thisVrfTU.coolCoilAirInNode = CCoilInletNodeNum;
-                        thisVrfTU.coolCoilAirOutNode = CCoilOutletNodeNum;
-
-                        if (errFlag) ShowContinueError(state, "...occurs in " + cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-
-                        SetDXCoolingCoilData(
-                            state, thisVrfTU.CoolCoilIndex, ErrorsFound, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserType);
-                        SetDXCoolingCoilData(
-                            state, thisVrfTU.CoolCoilIndex, ErrorsFound, _, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserNodeNum);
-                        SetDXCoolingCoilData(
-                            state, thisVrfTU.CoolCoilIndex, ErrorsFound, _, _, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATCCHeater);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.CoolCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MinOATCooling);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.CoolCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATCooling);
 
-                    } else {
-                        ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                        ShowContinueError(state, "... illegal " + cAlphaFieldNames(12) + " = " + cAlphaArgs(12));
-                        ErrorsFound = true;
+                        thisVrfTU.coolCoilAirInNode = DXCoils::GetCoilAirInletNode(state, thisVrfTU.CoolCoilNum);
+                        thisVrfTU.coolCoilAirOutNode = DXCoils::GetCoilAirOutletNode(state, thisVrfTU.CoolCoilNum);
+
+                        DXCoils::SetCoilCondenserType(state, thisVrfTU.CoolCoilNum, vrfCondenser.CondenserType);
+                        DXCoils::SetCoilCondenserInletNode(state, thisVrfTU.CoolCoilNum, vrfCondenser.CondenserNodeNum);
+                        DXCoils::SetCoilMaxOATCrankcaseHeater(state, thisVrfTU.CoolCoilNum, vrfCondenser.MaxOATCCHeater);
+                        DXCoils::SetCoilOATCoolingInfo(state, thisVrfTU.CoolCoilNum, vrfCondenser.MinOATCooling, vrfCondenser.MaxOATCooling);
                     }
+                } else {
+                    ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
+                    ShowContinueError(state, "... illegal " + cAlphaFieldNames(12) + " = " + cAlphaArgs(12));
+                    ErrorsFound = true;
                 }
-            } else {
-                ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                ShowContinueError(state, "... when checking " + HVAC::cAllCoilTypes(thisVrfTU.DXCoolCoilType_Num) + " \"" + cAlphaArgs(12) + "\"");
-                ShowContinueError(state, "... terminal unit not connected to condenser.");
-                ShowContinueError(state, "... check that terminal unit is specified in a terminal unit list object.");
-                ShowContinueError(
-                    state, "... also check that the terminal unit list name is specified in an AirConditioner:VariableRefrigerantFlow object.");
-                ErrorsFound = true;
             }
         }
 
-        // Get DX heating coil data
-        std::string DXHeatingCoilType = cAlphaArgs(13);
-
         // Get the heating to cooling sizing ratio input before writing to DX heating coil data
         if (!lNumericFieldBlanks(10)) {
             thisVrfTU.HeatingCapacitySizeRatio = rNumericArgs(10);
         }
 
         errFlag = false;
-        thisVrfTU.DXHeatCoilType_Num = GetCoilTypeNum(state, DXHeatingCoilType, cAlphaArgs(14), errFlag, false);
-        if (thisVrfTU.DXHeatCoilType_Num == 0) {
+        thisVrfTU.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, cAlphaArgs(13)));
+        thisVrfTU.HeatCoilName = cAlphaArgs(14);
+
+        if (thisVrfTU.heatCoilType == HVAC::CoilType::Invalid) {
             thisVrfTU.HeatingCoilPresent = false;
             if (thisVrfTU.TUListIndex > 0 && thisVrfTU.IndexToTUInTUList > 0) {
                 state.dataHVACVarRefFlow->TerminalUnitList(thisVrfTU.TUListIndex).HeatingCoilPresent(thisVrfTU.IndexToTUInTUList) = false;
             }
+
+        } else if (thisVrfTU.VRFSysNum == 0) {
+            thisVrfTU.HeatingCoilPresent = false;
+            ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
+            ShowContinueError(state, format("... when checking {} \"{}\"", HVAC::coilTypeNames[(int)thisVrfTU.heatCoilType], thisVrfTU.HeatCoilName));
+            ShowContinueError(state, "... terminal unit not connected to condenser.");
+            ShowContinueError(state, "... check that terminal unit is specified in a terminal unit list object.");
+            ShowContinueError(state,
+                              "... also check that the terminal unit list name is specified in an "
+                              "AirConditioner:VariableRefrigerantFlow object.");
+            ErrorsFound = true;
+
         } else {
-            if (thisVrfTU.VRFSysNum > 0) {
-                if (state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).VRFAlgorithmType == AlgorithmType::FluidTCtrl) {
-                    // Algorithm Type: VRF model based on physics, applicable for Fluid Temperature Control
+            auto &vrfCondenser = state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum);
+            if (vrfCondenser.VRFAlgorithmType == AlgorithmType::FluidTCtrl) {
+                // Algorithm Type: VRF model based on physics, applicable for Fluid Temperature Control
 
-                    if (Util::SameString(HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num), HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Heating))) {
-                        errFlag = false;
+                if (thisVrfTU.heatCoilType == HVAC::CoilType::HeatingVRFFluidTCtrl) {
+                    thisVrfTU.HeatCoilNum = DXCoils::GetCoilIndex(state, thisVrfTU.HeatCoilName);
+                    if (thisVrfTU.HeatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(14), thisVrfTU.HeatCoilName);
+                        ErrorsFound = true;
+                        thisVrfTU.HeatingCoilPresent = false;
+                            
+                    } else { // thisVrfTU.HeatCoilNum != 0
                         if (thisVrfTU.TUListIndex > 0 && thisVrfTU.IndexToTUInTUList > 0) {
                             state.dataHVACVarRefFlow->TerminalUnitList(thisVrfTU.TUListIndex).heatingCoilAvailScheds(thisVrfTU.IndexToTUInTUList) =
-                                DXCoils::GetDXCoilAvailSched(state, DXHeatingCoilType, cAlphaArgs(14), errFlag);
+                                DXCoils::GetCoilAvailSched(state, thisVrfTU.HeatCoilNum);
                         }
-                        GetDXCoilIndex(
-                            state, cAlphaArgs(14), thisVrfTU.HeatCoilIndex, errFlag, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Heating));
-                        HCoilInletNodeNum =
-                            DXCoils::GetCoilInletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Heating), cAlphaArgs(14), errFlag);
-                        HCoilOutletNodeNum =
-                            DXCoils::GetCoilOutletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_FluidTCtrl_Heating), cAlphaArgs(14), errFlag);
-                        thisVrfTU.heatCoilAirInNode = HCoilInletNodeNum;
-                        thisVrfTU.heatCoilAirOutNode = HCoilOutletNodeNum;
-
-                        if (errFlag) ShowContinueError(state, "...occurs in " + cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-
-                        if (thisVrfTU.VRFSysNum > 0) {
-                            SetDXCoolingCoilData(
-                                state, thisVrfTU.HeatCoilIndex, ErrorsFound, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserType);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserNodeNum);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATCCHeater);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MinOATHeating);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATHeating);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingPerformanceOATType);
-                            // Set defrost controls in child object to trip child object defrost calculations
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostStrategy);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostControl);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostEIRPtr);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostFraction);
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATDefrost);
-                            // If defrost is disabled in the VRF condenser, it must be disabled in the DX coil
-                            // Defrost primarily handled in parent object, set defrost capacity to 1 to avoid autosizing.
-                            // Defrost capacity is used for nothing more than setting defrost power/consumption report
-                            // variables which are not reported. The coil's defrost algorithm IS used to derate the coil
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 1.0); // DefrostCapacity=1.0
-
-                            state.dataDXCoils->DXCoil(thisVrfTU.HeatCoilIndex).VRFIUPtr = VRFTUNum;
-                            state.dataDXCoils->DXCoil(thisVrfTU.HeatCoilIndex).VRFOUPtr = thisVrfTU.VRFSysNum;
-                            state.dataDXCoils->DXCoil(thisVrfTU.HeatCoilIndex).SupplyFanIndex = thisVrfTU.FanIndex;
-
-                            if (thisVrfTU.FanIndex > 0) {
-                                state.dataDXCoils->DXCoil(thisVrfTU.HeatCoilIndex).RatedAirVolFlowRate(1) =
-                                    state.dataFans->fans(thisVrfTU.FanIndex)->maxAirFlowRate;
-                            } else {
-                                state.dataDXCoils->DXCoil(thisVrfTU.HeatCoilIndex).RatedAirVolFlowRate(1) = AutoSize;
-                            }
+                        thisVrfTU.heatCoilAirInNode = DXCoils::GetCoilAirInletNode(state, thisVrfTU.HeatCoilNum);
+                        thisVrfTU.heatCoilAirOutNode = DXCoils::GetCoilAirOutletNode(state, thisVrfTU.HeatCoilNum);
+                        
+                        DXCoils::SetCoilCondenserType(state, thisVrfTU.HeatCoilNum, vrfCondenser.CondenserType);
+                        DXCoils::SetCoilCondenserInletNode(state, thisVrfTU.HeatCoilNum, vrfCondenser.CondenserNodeNum);
+                        DXCoils::SetCoilMaxOATCrankcaseHeater(state, thisVrfTU.HeatCoilNum, vrfCondenser.MaxOATCCHeater);
+                        DXCoils::SetCoilOATHeatingInfo(state, thisVrfTU.HeatCoilNum,
+                            vrfCondenser.MinOATHeating, vrfCondenser.MaxOATHeating, vrfCondenser.HeatingPerformanceOATType);
+                        // Set defrost controls in child object to trip child object defrost calculations
+                        DXCoils::SetCoilDefrostInfo(state,
+                                                    thisVrfTU.HeatCoilNum,
+                                                    vrfCondenser.DefrostStrategy, 
+                                                    vrfCondenser.DefrostControl,
+                                                    vrfCondenser.DefrostEIRPtr,
+                                                    vrfCondenser.DefrostFraction, 
+                                                    vrfCondenser.MaxOATDefrost, 
 
-                            // Terminal unit heating to cooling sizing ratio has precedence over VRF system sizing ratio
-                            if (thisVrfTU.HeatingCapacitySizeRatio > 1.0) {
-                                SetDXCoolingCoilData(state,
-                                                     thisVrfTU.HeatCoilIndex,
-                                                     ErrorsFound,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     thisVrfTU.HeatingCapacitySizeRatio);
-                            } else if (state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingCapacitySizeRatio > 1.0) {
-                                SetDXCoolingCoilData(state,
-                                                     thisVrfTU.HeatCoilIndex,
-                                                     ErrorsFound,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     _,
-                                                     state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingCapacitySizeRatio);
-                            }
+                        // If defrost is disabled in the VRF condenser, it must be disabled in the DX coil
+                        // Defrost primarily handled in parent object, set defrost capacity to 1 to avoid autosizing.
+                        // Defrost capacity is used for nothing more than setting defrost power/consumption report
+                        // variables which are not reported. The coil's defrost algorithm IS used to derate the coil
+                                                    1.0); // DefrostCapacity=1.0
+
+                        auto &dxCoil = state.dataDXCoils->DXCoil(thisVrfTU.HeatCoilNum);
+                        dxCoil.VRFIUPtr = VRFTUNum;
+                        dxCoil.VRFOUPtr = thisVrfTU.VRFSysNum;
+                        dxCoil.SupplyFanIndex = thisVrfTU.FanIndex; // This is available via the API
+                        
+                        if (thisVrfTU.FanIndex > 0) {
+                            dxCoil.RatedAirVolFlowRate(1) = state.dataFans->fans(thisVrfTU.FanIndex)->maxAirFlowRate;
                         } else {
-                            ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                            ShowContinueError(
-                                state, "... when checking " + HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num) + " \"" + cAlphaArgs(14) + "\"");
-                            ShowContinueError(state, "... terminal unit not connected to condenser.");
-                            ShowContinueError(state, "... check that terminal unit is specified in a terminal unit list object.");
-                            ShowContinueError(state,
-                                              "... also check that the terminal unit list name is specified in an "
-                                              "AirConditioner:VariableRefrigerantFlow object.");
-                            ErrorsFound = true;
+                            dxCoil.RatedAirVolFlowRate(1) = AutoSize;
                         }
-                    } else {
-                        ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                        ShowContinueError(state, "... illegal " + cAlphaFieldNames(14) + " = " + cAlphaArgs(14));
-                        ErrorsFound = true;
-                    }
 
+                        // Terminal unit heating to cooling sizing ratio has precedence over VRF system sizing ratio
+                        if (thisVrfTU.HeatingCapacitySizeRatio > 1.0) {
+                            DXCoils::SetCoilHeatSizeRatio(state, thisVrfTU.HeatCoilNum, thisVrfTU.HeatingCapacitySizeRatio);
+                        } else if (vrfCondenser.HeatingCapacitySizeRatio > 1.0) {
+                            DXCoils::SetCoilHeatSizeRatio(state, thisVrfTU.HeatCoilNum, vrfCondenser.HeatingCapacitySizeRatio);
+                        }
+                    }
                 } else {
-                    // Algorithm Type: VRF model based on system curve
-                    if (Util::SameString(HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num), HVAC::cAllCoilTypes(HVAC::CoilVRF_Heating))) {
+                    ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
+                    ShowContinueError(state, "... illegal " + cAlphaFieldNames(14) + " = " + cAlphaArgs(14));
+                    ErrorsFound = true;
+                }
+                
+            } else { // Algorithm Type: VRF model based on system curve
+                    
+                if (thisVrfTU.heatCoilType == HVAC::CoilType::HeatingVRF) {
+                    thisVrfTU.HeatCoilNum = DXCoils::GetCoilIndex(state, thisVrfTU.HeatCoilName);
+                    if (thisVrfTU.HeatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(14), thisVrfTU.HeatCoilName);
+                        ErrorsFound = true;
+                        thisVrfTU.HeatingCoilPresent = false;
+                    } else { // thisVrfTU.HeatCoilNum != 0
                         if (thisVrfTU.TUListIndex > 0 && thisVrfTU.IndexToTUInTUList > 0) {
                             state.dataHVACVarRefFlow->TerminalUnitList(thisVrfTU.TUListIndex).heatingCoilAvailScheds(thisVrfTU.IndexToTUInTUList) =
-                                DXCoils::GetDXCoilAvailSched(state, DXHeatingCoilType, cAlphaArgs(14), errFlag);
+                                DXCoils::GetCoilAvailSched(state, thisVrfTU.HeatCoilNum);
                         } else {
                             thisVrfTU.HeatingCoilPresent = false;
                         }
-                        errFlag = false;
-                        GetDXCoilIndex(state, cAlphaArgs(14), thisVrfTU.HeatCoilIndex, errFlag, HVAC::cAllCoilTypes(HVAC::CoilVRF_Heating));
-                        HCoilInletNodeNum = DXCoils::GetCoilInletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Heating), cAlphaArgs(14), errFlag);
-                        HCoilOutletNodeNum = DXCoils::GetCoilOutletNode(state, HVAC::cAllCoilTypes(HVAC::CoilVRF_Heating), cAlphaArgs(14), errFlag);
-                        thisVrfTU.heatCoilAirInNode = HCoilInletNodeNum;
-                        thisVrfTU.heatCoilAirOutNode = HCoilOutletNodeNum;
-
-                        if (errFlag) ShowContinueError(state, "...occurs in " + cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-
-                        SetDXCoolingCoilData(
-                            state, thisVrfTU.HeatCoilIndex, ErrorsFound, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserType);
-                        SetDXCoolingCoilData(
-                            state, thisVrfTU.HeatCoilIndex, ErrorsFound, _, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).CondenserNodeNum);
-                        SetDXCoolingCoilData(
-                            state, thisVrfTU.HeatCoilIndex, ErrorsFound, _, _, _, state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATCCHeater);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MinOATHeating);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingPerformanceOATType);
+
+                        // Why would we do this if thisVrfTU.HeatingCoilPresent is false?
+                        thisVrfTU.heatCoilAirInNode = DXCoils::GetCoilAirInletNode(state, thisVrfTU.HeatCoilNum);
+                        thisVrfTU.heatCoilAirOutNode = DXCoils::GetCoilAirOutletNode(state, thisVrfTU.HeatCoilNum);
+
+                        DXCoils::SetCoilCondenserType(state, thisVrfTU.HeatCoilNum, vrfCondenser.CondenserType);
+                        DXCoils::SetCoilCondenserInletNode(state, thisVrfTU.HeatCoilNum, vrfCondenser.CondenserNodeNum);
+                        DXCoils::SetCoilMaxOATCrankcaseHeater(state, thisVrfTU.HeatCoilNum, vrfCondenser.MaxOATCCHeater);
+                        DXCoils::SetCoilOATHeatingInfo(state, thisVrfTU.HeatCoilNum,
+                            vrfCondenser.MinOATHeating, vrfCondenser.MaxOATHeating, vrfCondenser.HeatingPerformanceOATType);
+                        
                         // Set defrost controls in child object to trip child object defrost calculations
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostStrategy);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostControl);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostEIRPtr);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).DefrostFraction);
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).MaxOATDefrost);
+                        DXCoils::SetCoilDefrostInfo(state,
+                                                    thisVrfTU.HeatCoilNum,
+                                                    vrfCondenser.DefrostStrategy,
+                                                    vrfCondenser.DefrostControl, 
+                                                    vrfCondenser.DefrostEIRPtr, 
+                                                    vrfCondenser.DefrostFraction,
+                                                    vrfCondenser.MaxOATDefrost, 
                         // If defrost is disabled in the VRF condenser, it must be disabled in the DX coil
                         // Defrost primarily handled in parent object, set defrost capacity to 1 to avoid autosizing.
                         // Defrost capacity is used for nothing more than setting defrost power/consumption report
                         // variables which are not reported. The coil's defrost algorithm IS used to derate the coil
-                        SetDXCoolingCoilData(state,
-                                             thisVrfTU.HeatCoilIndex,
-                                             ErrorsFound,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             _,
-                                             1.0); // DefrostCapacity=1.0
+                                                    1.0); // DefrostCapacity=1.0
+                        
                         // Terminal unit heating to cooling sizing ratio has precedence over VRF system sizing ratio
                         if (thisVrfTU.HeatingCapacitySizeRatio > 1.0) {
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 thisVrfTU.HeatingCapacitySizeRatio);
-                        } else if (state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingCapacitySizeRatio > 1.0) {
-                            SetDXCoolingCoilData(state,
-                                                 thisVrfTU.HeatCoilIndex,
-                                                 ErrorsFound,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 _,
-                                                 state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingCapacitySizeRatio);
+                            DXCoils::SetCoilHeatSizeRatio(state, thisVrfTU.HeatCoilNum, thisVrfTU.HeatingCapacitySizeRatio);
+                        } else if (vrfCondenser.HeatingCapacitySizeRatio > 1.0) {
+                            DXCoils::SetCoilHeatSizeRatio(state, thisVrfTU.HeatCoilNum, vrfCondenser.HeatingCapacitySizeRatio);
                         }
                         // Check VRF DX heating coil heating capacity as a function of temperature performance curve. Only report here for
                         // biquadratic curve type.
-                        if (thisVrfTU.VRFSysNum > 0 && thisVrfTU.HeatCoilIndex > 0 &&
-                            state.dataCurveManager->curves(GetDXCoilCapFTCurveIndex(state, thisVrfTU.HeatCoilIndex, ErrorsFound))->numDims == 2) {
-                            if (state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingPerformanceOATType == HVAC::OATType::WetBulb) {
+                        int heatCoilCapFTCurveNum = DXCoils::GetCoilCapFTCurve(state, thisVrfTU.HeatCoilNum);
+                        if (state.dataCurveManager->curves(heatCoilCapFTCurveNum)->numDims == 2) {
+                            if (vrfCondenser.HeatingPerformanceOATType == HVAC::OATType::WetBulb) {
                                 checkCurveIsNormalizedToOne(
                                     state,
-                                    "GetDXCoils: " + HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num),
-                                    DXCoils::GetDXCoilName(
-                                        state, thisVrfTU.HeatCoilIndex, ErrorsFound, HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num)),
-                                    GetDXCoilCapFTCurveIndex(state, thisVrfTU.HeatCoilIndex, ErrorsFound),
+                                    format("GetDXCoils: {}", HVAC::coilTypeNames[(int)thisVrfTU.heatCoilType]),
+                                    thisVrfTU.HeatCoilName,
+                                    heatCoilCapFTCurveNum,
                                     "Heating Capacity Ratio Modifier Function of Temperature Curve Name",
-                                    Curve::GetCurveName(state, GetDXCoilCapFTCurveIndex(state, thisVrfTU.HeatCoilIndex, ErrorsFound)),
-                                    RatedInletAirTempHeat,
-                                    RatedOutdoorWetBulbTempHeat);
-                            } else if (state.dataHVACVarRefFlow->VRF(thisVrfTU.VRFSysNum).HeatingPerformanceOATType == HVAC::OATType::DryBulb) {
+                                    state.dataCurveManager->curves(heatCoilCapFTCurveNum)->Name,
+                                    DXCoils::RatedInletAirTempHeat,
+                                    DXCoils::RatedOutdoorWetBulbTempHeat);
+                            } else if (vrfCondenser.HeatingPerformanceOATType == HVAC::OATType::DryBulb) {
                                 checkCurveIsNormalizedToOne(
                                     state,
-                                    "GetDXCoils: " + HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num),
-                                    DXCoils::GetDXCoilName(
-                                        state, thisVrfTU.HeatCoilIndex, ErrorsFound, HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num)),
-                                    GetDXCoilCapFTCurveIndex(state, thisVrfTU.HeatCoilIndex, ErrorsFound),
+                                    format("GetDXCoils: {}", HVAC::coilTypeNames[(int)thisVrfTU.heatCoilType]),
+                                    thisVrfTU.HeatCoilName,
+                                    heatCoilCapFTCurveNum,
                                     "Heating Capacity Ratio Modifier Function of Temperature Curve Name",
-                                    Curve::GetCurveName(state, GetDXCoilCapFTCurveIndex(state, thisVrfTU.HeatCoilIndex, ErrorsFound)),
-                                    RatedInletAirTempHeat,
-                                    RatedOutdoorAirTempHeat);
+                                    state.dataCurveManager->curves(heatCoilCapFTCurveNum)->Name,
+                                    DXCoils::RatedInletAirTempHeat,
+                                    DXCoils::RatedOutdoorAirTempHeat);
                             }
                         }
-
-                    } else {
-                        ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                        ShowContinueError(state, "... illegal " + cAlphaFieldNames(14) + " = " + cAlphaArgs(14));
-                        ErrorsFound = true;
                     }
+                } else {
+                    ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
+                    ShowContinueError(state, "... illegal " + cAlphaFieldNames(14) + " = " + cAlphaArgs(14));
+                    ErrorsFound = true;
                 }
-            } else {
-                ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
-                ShowContinueError(state, "... when checking " + HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num) + " \"" + cAlphaArgs(14) + "\"");
-                ShowContinueError(state, "... terminal unit not connected to condenser.");
-                ShowContinueError(state, "... check that terminal unit is specified in a terminal unit list object.");
-                ShowContinueError(
-                    state, "... also check that the terminal unit list name is specified in an AirConditioner:VariableRefrigerantFlow object.");
-                ErrorsFound = true;
             }
         }
+        
 
-        if (!thisVrfTU.CoolingCoilPresent && thisVrfTU.DXCoolCoilType_Num == 0 && !thisVrfTU.HeatingCoilPresent &&
-            thisVrfTU.DXHeatCoilType_Num == 0) {
+        if (!thisVrfTU.CoolingCoilPresent && thisVrfTU.coolCoilType == HVAC::CoilType::Invalid &&
+            !thisVrfTU.HeatingCoilPresent && thisVrfTU.heatCoilType == HVAC::CoilType::Invalid) {
             ShowSevereError(state, cCurrentModuleObject + " \"" + thisVrfTU.Name + "\"");
             ShowContinueError(state, "... no valid coils entered for this terminal unit. Simulation will not proceed.");
             ErrorsFound = true;
@@ -4122,158 +3727,56 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
         // supplemental heating coil
         if (!lAlphaFieldBlanks(17) && !lAlphaFieldBlanks(18)) {
 
-            thisVrfTU.SuppHeatCoilType = cAlphaArgs(17);
+            thisVrfTU.suppHeatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, cAlphaArgs(17)));
             thisVrfTU.SuppHeatCoilName = cAlphaArgs(18);
 
-            errFlag = false;
-            if (Util::SameString(thisVrfTU.SuppHeatCoilType, "Coil:Heating:Water")) {
-                thisVrfTU.SuppHeatCoilType_Num = HVAC::Coil_HeatingWater;
-            } else if (Util::SameString(thisVrfTU.SuppHeatCoilType, "Coil:Heating:Steam")) {
-                thisVrfTU.SuppHeatCoilType_Num = HVAC::Coil_HeatingSteam;
-            } else if (Util::SameString(thisVrfTU.SuppHeatCoilType, "Coil:Heating:Fuel") ||
-                       Util::SameString(thisVrfTU.SuppHeatCoilType, "Coil:Heating:Electric")) {
-                thisVrfTU.SuppHeatCoilType_Num =
-                    HeatingCoils::GetHeatingCoilTypeNum(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, errFlag);
-            }
-
             thisVrfTU.SuppHeatingCoilPresent = true;
 
-            if (thisVrfTU.SuppHeatCoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel || thisVrfTU.SuppHeatCoilType_Num == HVAC::Coil_HeatingElectric) {
-                errFlag = false;
-                thisVrfTU.SuppHeatCoilType_Num =
-                    HeatingCoils::GetHeatingCoilTypeNum(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
+            if (thisVrfTU.suppHeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                thisVrfTU.suppHeatCoilType == HVAC::CoilType::HeatingElectric) {
+                // mine data from supplemental heating coil
+                // Get the supplemental heating coil index
+                thisVrfTU.SuppHeatCoilNum = HeatingCoils::GetCoilIndex(state, thisVrfTU.SuppHeatCoilName);
+                if (thisVrfTU.SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(18), thisVrfTU.SuppHeatCoilName);
                     ErrorsFound = true;
                 } else {
-                    ValidateComponent(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, IsNotOK, cCurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    } else { // mine data from supplemental heating coil
-                        // Get the supplemental heating coil index
-                        thisVrfTU.SuppHeatCoilIndex =
-                            HeatingCoils::GetHeatingCoilIndex(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, IsNotOK);
-                        if (IsNotOK) {
-                            ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                            ErrorsFound = true;
-                        }
-                        // Get the design supplemental heating capacity
-                        errFlag = false;
-                        thisVrfTU.DesignSuppHeatingCapacity =
-                            HeatingCoils::GetCoilCapacity(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                            ErrorsFound = true;
-                        }
-                        // Get the supplemental heating Coil air inlet node
-                        errFlag = false;
-                        thisVrfTU.SuppHeatCoilAirInletNode =
-                            HeatingCoils::GetCoilInletNode(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                            ErrorsFound = true;
-                        }
-                        // Get the supplemental heating Coil air outlet node
-                        errFlag = false;
-                        thisVrfTU.SuppHeatCoilAirOutletNode =
-                            HeatingCoils::GetCoilOutletNode(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                            ErrorsFound = true;
-                        }
-                    } // IF (IsNotOK) THEN
+                    thisVrfTU.DesignSuppHeatingCapacity = HeatingCoils::GetCoilCapacity(state, thisVrfTU.SuppHeatCoilNum);
+                    thisVrfTU.SuppHeatCoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, thisVrfTU.SuppHeatCoilNum);
+                    thisVrfTU.SuppHeatCoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, thisVrfTU.SuppHeatCoilNum);
                 }
 
-            } else if (thisVrfTU.SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+            } else if (thisVrfTU.suppHeatCoilType == HVAC::CoilType::HeatingWater) {
 
-                ValidateComponent(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, IsNotOK, cCurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                    ErrorsFound = true;
-                } else { // mine data from heating coil object
-
-                    // Get the supplemental heating coil water Inlet or control node number
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilFluidInletNode =
-                        WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    }
-                    // Get the supplemental heating coil hot water max volume flow rate
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilFluidMaxFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    }
-                    // Get the supplemental heating Coil air inlet node
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilAirInletNode =
-                        WaterCoils::GetCoilInletNode(state, "Coil:Heating:Water", thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    }
-                    // Get the supplemental heating coil air outlet node
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilAirOutletNode =
-                        WaterCoils::GetCoilOutletNode(state, "Coil:Heating:Water", thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    }
-                }
+              thisVrfTU.SuppHeatCoilNum = WaterCoils::GetCoilIndex(state, thisVrfTU.SuppHeatCoilName);
+              if (thisVrfTU.SuppHeatCoilNum == 0) {
+                  ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(18), thisVrfTU.SuppHeatCoilName);
+                  ErrorsFound = true;
+              } else {
+                  thisVrfTU.SuppHeatCoilFluidInletNode = WaterCoils::GetCoilWaterInletNode(state, thisVrfTU.SuppHeatCoilNum);
+                  thisVrfTU.SuppHeatCoilFluidMaxFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, thisVrfTU.SuppHeatCoilNum);
+                  thisVrfTU.SuppHeatCoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, thisVrfTU.SuppHeatCoilNum);
+                  thisVrfTU.SuppHeatCoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, thisVrfTU.SuppHeatCoilNum);
+              }
 
-            } else if (thisVrfTU.SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+            } else if (thisVrfTU.suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
 
-                ValidateComponent(state, thisVrfTU.SuppHeatCoilType, thisVrfTU.SuppHeatCoilName, IsNotOK, cCurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
+                thisVrfTU.SuppHeatCoilNum = SteamCoils::GetCoilIndex(state, thisVrfTU.SuppHeatCoilName);
+                if (thisVrfTU.SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(18), thisVrfTU.SuppHeatCoilName);
                     ErrorsFound = true;
-                } else { // mine data from supplemental heating coil object
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (thisVrfTU.SuppHeatCoilIndex == 0) {
-                        ShowSevereError(state, cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    }
-                    // Get the supplemental heating Coil steam inlet node number
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilFluidInletNode =
-                        SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    }
-                    // Get the supplemental heating coil steam max volume flow rate
-                    thisVrfTU.SuppHeatCoilFluidMaxFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisVrfTU.SuppHeatCoilIndex, errFlag);
+                } else {
+                    thisVrfTU.SuppHeatCoilFluidInletNode = SteamCoils::GetCoilSteamInletNode(state, thisVrfTU.SuppHeatCoilNum);
+                    thisVrfTU.SuppHeatCoilFluidMaxFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, thisVrfTU.SuppHeatCoilNum);
                     if (thisVrfTU.SuppHeatCoilFluidMaxFlow > 0.0) {
-                        Real64 TempSteamIn = 100.0;
-                        Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
-                        thisVrfTU.SuppHeatCoilFluidMaxFlow =
-                            SteamCoils::GetCoilMaxSteamFlowRate(state, thisVrfTU.SuppHeatCoilIndex, errFlag) * SteamDensity;
-                    }
-                    // Get the supplemental heating coil air inlet node
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilAirInletNode =
-                        SteamCoils::GetCoilAirInletNode(state, thisVrfTU.SuppHeatCoilIndex, thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
-                    }
-                    // Get the supplemental heating coil air outlet node
-                    errFlag = false;
-                    thisVrfTU.SuppHeatCoilAirOutletNode =
-                        SteamCoils::GetCoilAirOutletNode(state, thisVrfTU.SuppHeatCoilIndex, thisVrfTU.SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, "Occurs in " + cCurrentModuleObject + " = " + thisVrfTU.Name);
-                        ErrorsFound = true;
+                        thisVrfTU.SuppHeatCoilFluidMaxFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                     }
+
+                    thisVrfTU.SuppHeatCoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, thisVrfTU.SuppHeatCoilNum);
+                    thisVrfTU.SuppHeatCoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, thisVrfTU.SuppHeatCoilNum);
                 }
             }
+            
         } else { // if (!lAlphaFieldBlanks(17) && !lAlphaFieldBlanks(18)) {
             if (!lAlphaFieldBlanks(17) && lAlphaFieldBlanks(18)) {
                 ShowWarningError(state, cCurrentModuleObject + " = " + thisVrfTU.Name + "\"");
@@ -4304,7 +3807,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
             vrfTU.DesignSpecMultispeedHPName = cAlphaArgs(21);
             vrfTU.DesignSpecMSHPIndex = UnitarySystems::getDesignSpecMSHPIndex(state, cAlphaArgs(21));
             auto const &designSpecFan = state.dataUnitarySystems->designSpecMSHP[vrfTU.DesignSpecMSHPIndex];
-            if (vrfTU.DXCoolCoilType_Num == HVAC::CoilVRF_Cooling) {
+            if (vrfTU.coolCoilType == HVAC::CoilType::CoolingVRF) {
                 int NumSpeeds = designSpecFan.numOfSpeedCooling;
                 vrfTU.NumOfSpeedCooling = NumSpeeds;
                 vrfTU.CoolVolumeFlowRate.resize(NumSpeeds + 1);
@@ -4322,7 +3825,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
                     }
                 }
             }
-            if (vrfTU.DXHeatCoilType_Num == HVAC::CoilVRF_Heating) {
+            if (vrfTU.heatCoilType == HVAC::CoilType::HeatingVRF) {
                 int NumSpeeds = designSpecFan.numOfSpeedHeating;
                 vrfTU.NumOfSpeedHeating = NumSpeeds;
                 vrfTU.HeatVolumeFlowRate.resize(NumSpeeds + 1);
@@ -4347,12 +3850,12 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
 
                 if (fanSystem->speedControl == Fans::SpeedControl::Discrete) {
                     if (fanSystem->numSpeeds > 1) {
-                        if (vrfTU.DXCoolCoilType_Num == HVAC::CoilVRF_Cooling) {
+                        if (vrfTU.coolCoilType == HVAC::CoilType::CoolingVRF) {
                             vrfTU.NumOfSpeedCooling = fanSystem->numSpeeds;
                             vrfTU.CoolVolumeFlowRate.resize(fanSystem->numSpeeds + 1);
                             vrfTU.CoolMassFlowRate.resize(fanSystem->numSpeeds + 1);
                         }
-                        if (vrfTU.DXHeatCoilType_Num == HVAC::CoilVRF_Heating) {
+                        if (vrfTU.heatCoilType == HVAC::CoilType::HeatingVRF) {
                             vrfTU.NumOfSpeedHeating = fanSystem->numSpeeds;
                             vrfTU.HeatVolumeFlowRate.resize(fanSystem->numSpeeds + 1);
                             vrfTU.HeatMassFlowRate.resize(fanSystem->numSpeeds + 1);
@@ -4388,13 +3891,12 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
             SetUpCompSets(state,
                           cCurrentModuleObject,
                           thisVrfTU.Name,
-                          HVAC::cAllCoilTypes(thisVrfTU.DXCoolCoilType_Num),
+                          HVAC::coilTypeNames[(int)thisVrfTU.coolCoilType],
                           cAlphaArgs(12),
-                          state.dataLoopNodes->NodeID(CCoilInletNodeNum),
-                          state.dataLoopNodes->NodeID(CCoilOutletNodeNum));
+                          state.dataLoopNodes->NodeID(thisVrfTU.coolCoilAirInNode),
+                          state.dataLoopNodes->NodeID(thisVrfTU.coolCoilAirOutNode));
             //     set heating coil present flag
-            SetDXCoolingCoilData(
-                state, thisVrfTU.CoolCoilIndex, ErrorsFound, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, thisVrfTU.HeatingCoilPresent);
+            DXCoils::SetCoilHeatingCoilPresent(state, vrfTU.CoolCoilNum, vrfTU.HeatingCoilPresent);
 
             //   check that curve types are present in VRF Condenser if cooling coil is present in terminal unit (can be blank)
             //   all curves are checked for correct type if a curve name is entered in the VRF condenser object. Check that the
@@ -4425,13 +3927,12 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
             SetUpCompSets(state,
                           cCurrentModuleObject,
                           thisVrfTU.Name,
-                          HVAC::cAllCoilTypes(thisVrfTU.DXHeatCoilType_Num),
+                          HVAC::coilTypeNames[(int)thisVrfTU.heatCoilType],
                           cAlphaArgs(14),
-                          state.dataLoopNodes->NodeID(HCoilInletNodeNum),
-                          state.dataLoopNodes->NodeID(HCoilOutletNodeNum));
+                          state.dataLoopNodes->NodeID(thisVrfTU.heatCoilAirInNode),
+                          state.dataLoopNodes->NodeID(thisVrfTU.heatCoilAirOutNode));
             //     set cooling coil present flag
-            SetDXCoolingCoilData(
-                state, thisVrfTU.HeatCoilIndex, ErrorsFound, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, thisVrfTU.CoolingCoilPresent);
+            DXCoils::SetCoilCoolingCoilPresent(state, vrfTU.HeatCoilNum, vrfTU.CoolingCoilPresent);
 
             if (thisVrfTU.VRFSysNum > 0) {
 
@@ -4496,7 +3997,7 @@ void GetVRFInputData(EnergyPlusData &state, bool &ErrorsFound)
             SetUpCompSets(state,
                           cCurrentModuleObject,
                           thisVrfTU.Name,
-                          HVAC::cAllCoilTypes(thisVrfTU.SuppHeatCoilType_Num),
+                          HVAC::coilTypeNames[(int)thisVrfTU.suppHeatCoilType],
                           thisVrfTU.SuppHeatCoilName,
                           state.dataLoopNodes->NodeID(thisVrfTU.SuppHeatCoilAirInletNode),
                           state.dataLoopNodes->NodeID(thisVrfTU.SuppHeatCoilAirOutletNode));
@@ -5575,7 +5076,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
     }
 
     if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).MySuppCoilPlantScanFlag && allocated(state.dataPlnt->PlantLoop)) {
-        if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+        if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingWater) {
             // hot water supplemental heating coil
             errFlag = false;
             PlantUtilities::ScanPlantLoopsForObject(state,
@@ -5590,16 +5091,14 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
                                                     _);
 
             WaterCoils::SetCoilDesFlow(state,
-                                       HVAC::cAllCoilTypes(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num),
-                                       state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
-                                       state.dataHVACVarRefFlow->VRFTU(VRFTUNum).MaxHeatAirVolFlow,
-                                       errFlag);
+                                       state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum,
+                                       state.dataHVACVarRefFlow->VRFTU(VRFTUNum).MaxHeatAirVolFlow);
 
             if (errFlag) {
                 ShowFatalError(state, format("{}: Program terminated for previous conditions.", RoutineName));
             }
             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = WaterCoils::GetCoilMaxWaterFlowRate(
-                state, "Coil:Heating:Water", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound);
+                state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum);
 
             if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow > 0.0) {
                 rho = state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum)
@@ -5613,7 +5112,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
                 DataPlant::CompData::getPlantComponent(state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc).NodeNumOut;
             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).MySuppCoilPlantScanFlag = false;
 
-        } else if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+        } else if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
             // steam supplemental heating coil
             errFlag = false;
             PlantUtilities::ScanPlantLoopsForObject(state,
@@ -5630,7 +5129,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
                 ShowFatalError(state, format("{}: Program terminated for previous conditions.", RoutineName));
             }
             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow =
-                SteamCoils::GetCoilMaxSteamFlowRate(state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex, ErrorsFound);
+                SteamCoils::GetCoilMaxSteamFlowRate(state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum);
             if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow > 0.0) {
                 Real64 TempSteamIn = 100.0;
                 Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
@@ -6225,15 +5724,15 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
         //    END IF
 
         if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidInletNode > 0) {
-            if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingWater) {
                 if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow == DataSizing::AutoSize) {
                     WaterCoils::SimulateWaterCoilComponents(state,
                                                             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
                                                             FirstHVACIteration,
-                                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex);
+                                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum);
                     // design hot water volume flow rate
                     Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(
-                        state, "Coil:Heating:Water", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound);
+                        state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum);
                     if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                         rho = state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum)
                                   .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
@@ -6242,16 +5741,16 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
                 }
             }
 
-            if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+            if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                 if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow == DataSizing::AutoSize) {
                     SteamCoils::SimulateSteamCoilComponents(state,
                                                             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
                                                             FirstHVACIteration,
-                                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex,
+                                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum,
                                                             1.0);
                     // design steam volume flow rate
                     Real64 CoilMaxVolFlowRate =
-                        SteamCoils::GetCoilMaxSteamFlowRate(state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex, ErrorsFound);
+                        SteamCoils::GetCoilMaxSteamFlowRate(state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum);
                     if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                         Real64 TempSteamIn = 100.0;
                         Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
@@ -6311,7 +5810,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
     // get operating capacity of water and steam coil
     if (FirstHVACIteration) {
         if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidInletNode > 0) {
-            if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingWater) {
                 //     set hot water full flow rate for sizing
                 Real64 mdot = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow;
                 PlantUtilities::SetComponentFlowRate(state,
@@ -6324,11 +5823,11 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
                 WaterCoils::SimulateWaterCoilComponents(state,
                                                         state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
                                                         FirstHVACIteration,
-                                                        state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex,
+                                                        state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum,
                                                         SuppHeatCoilCapacity);
                 state.dataHVACVarRefFlow->VRFTU(VRFTUNum).DesignSuppHeatingCapacity = SuppHeatCoilCapacity;
-            } // from iF VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingWater
-            if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+
+            } else if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                 //     set hot water full flow rate for sizing
                 Real64 mdot = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow;
                 PlantUtilities::SetComponentFlowRate(state,
@@ -6341,11 +5840,10 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
                 SteamCoils::SimulateSteamCoilComponents(state,
                                                         state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
                                                         FirstHVACIteration,
-                                                        state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex,
+                                                        state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum,
                                                         1.0,
                                                         ErrorsFound); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                SuppHeatCoilCapacity =
-                    SteamCoils::GetCoilCapacity(state, "Coil:Heating:Steam", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound);
+                SuppHeatCoilCapacity = SteamCoils::GetCoilCapacity(state, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum);
 
                 state.dataHVACVarRefFlow->VRFTU(VRFTUNum).DesignSuppHeatingCapacity = SuppHeatCoilCapacity;
             } // from if VRFTU( VRFTUNum ).SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam
@@ -6373,14 +5871,14 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool
                         if (fanSystem->speedControl == Fans::SpeedControl::Discrete &&
                             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).DesignSpecMSHPIndex < 0) {
                             if (fanSystem->numSpeeds > 1) {
-                                if (vrfTU.DXCoolCoilType_Num == HVAC::CoilVRF_Cooling) {
+                                if (vrfTU.coolCoilType == HVAC::CoilType::CoolingVRF) {
                                     if (vrfTU.MaxCoolAirVolFlow != DataSizing::AutoSize) {
                                         for (int i = 1; i <= vrfTU.NumOfSpeedCooling; ++i) {
                                             vrfTU.CoolMassFlowRate[i] = fanSystem->massFlowAtSpeed[i - 1];
                                         }
                                     }
                                 }
-                                if (vrfTU.DXHeatCoilType_Num == HVAC::CoilVRF_Heating) {
+                                if (vrfTU.heatCoilType == HVAC::CoilType::HeatingVRF) {
                                     if (vrfTU.MaxHeatAirVolFlow != DataSizing::AutoSize) {
                                         for (int i = 1; i <= vrfTU.NumOfSpeedCooling; ++i) {
                                             vrfTU.HeatMassFlowRate[i] = fanSystem->massFlowAtSpeed[i - 1];
@@ -8275,21 +7773,19 @@ void SizeVRF(EnergyPlusData &state, int const VRFTUNum)
         state.dataHVACVarRefFlow->VRFTU(VRFTUNum).MaxSATFromSuppHeatCoil = sizerMaxHeaterOutTemp.size(state, TempSize, ErrorsFound);
     }
 
-    if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+    if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingWater) {
         bool ErrorsFound = false;
         WaterCoils::SetCoilDesFlow(state,
-                                   state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType,
-                                   state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
-                                   state.dataHVACVarRefFlow->VRFTU(VRFTUNum).MaxHeatAirVolFlow,
-                                   ErrorsFound);
+                                   state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum,
+                                   state.dataHVACVarRefFlow->VRFTU(VRFTUNum).MaxHeatAirVolFlow);
     }
 
     if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatingCoilPresent) {
-        CompType = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType;
+        CompType = HVAC::coilTypeNames[(int)state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType];
         CompName = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName;
         PrintFlag = false; // why isn't this being reported?
         TempSize = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).DesignSuppHeatingCapacity;
-        if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+        if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).suppHeatCoilType == HVAC::CoilType::HeatingWater) {
             // sizing result should always be reported
             if (TempSize == DataSizing::AutoSize) {
                 WaterHeatingCapacitySizer sizerWaterHeatingCapacity;
@@ -8352,22 +7848,16 @@ void SizeVRF(EnergyPlusData &state, int const VRFTUNum)
         int TUListNum = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).TUListIndex;
         for (int NumTU = 1; NumTU <= state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).NumTUInList; ++NumTU) {
             int TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-            if (state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex > 0) {
-                DXCoilCap = DXCoils::GetCoilCapacityByIndexType(state,
-                                                                state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex,
-                                                                state.dataHVACVarRefFlow->VRFTU(TUIndex).DXCoolCoilType_Num,
-                                                                errFlag);
+            if (state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum > 0) {
+                DXCoilCap = DXCoils::GetCoilCapacity(state, state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum);
                 TUCoolingCapacity += DXCoilCap;
                 if (DXCoilCap == AutoSize) {
                     FoundAll = false;
                     break;
                 }
             }
-            if (state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex > 0) {
-                DXCoilCap = DXCoils::GetCoilCapacityByIndexType(state,
-                                                                state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex,
-                                                                state.dataHVACVarRefFlow->VRFTU(TUIndex).DXHeatCoilType_Num,
-                                                                errFlag);
+            if (state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilNum > 0) {
+                DXCoilCap = DXCoils::GetCoilCapacity(state, state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilNum);
                 TUHeatingCapacity += DXCoilCap;
                 if (DXCoilCap == AutoSize) {
                     FoundAll = false;
@@ -8928,14 +8418,14 @@ void SimVRF(EnergyPlusData &state,
             0.0) { // set coil inlet conditions when coil does not operate. Inlet conditions are set in ControlVRF_FluidTCtrl when PLR=1
             if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).CoolingCoilPresent) {
                 state.dataHVACVarRefFlow->VRFTU(VRFTUNum).coilInNodeT =
-                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).CoolCoilIndex).AirInNode).Temp;
+                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).CoolCoilNum).AirInNode).Temp;
                 state.dataHVACVarRefFlow->VRFTU(VRFTUNum).coilInNodeW =
-                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).CoolCoilIndex).AirInNode).HumRat;
+                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).CoolCoilNum).AirInNode).HumRat;
             } else {
                 state.dataHVACVarRefFlow->VRFTU(VRFTUNum).coilInNodeT =
-                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).HeatCoilIndex).AirInNode).Temp;
+                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).HeatCoilNum).AirInNode).Temp;
                 state.dataHVACVarRefFlow->VRFTU(VRFTUNum).coilInNodeW =
-                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).HeatCoilIndex).AirInNode).HumRat;
+                    state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).HeatCoilNum).AirInNode).HumRat;
             }
         }
         // CalcVRF( VRFTUNum, FirstHVACIteration, PartLoadRatio, SysOutputProvided, OnOffAirFlowRatio, LatOutputProvided );
@@ -9452,10 +8942,10 @@ void VRFTerminalUnitEquipment::CalcVRF(EnergyPlusData &state,
             (state.dataHVACVarRefFlow->VRF(VRFCond).HeatRecoveryUsed &&
              state.dataHVACVarRefFlow->TerminalUnitList(TUListIndex).HRCoolRequest(IndexToTUInTUList))) {
             SimDXCoil(state,
-                      "",
+                      this->CoolCoilName,
                       HVAC::CompressorOp::On,
                       FirstHVACIteration,
-                      this->CoolCoilIndex,
+                      this->CoolCoilNum,
                       fanOp,
                       PartLoadRatio,
                       OnOffAirFlowRatio,
@@ -9463,7 +8953,7 @@ void VRFTerminalUnitEquipment::CalcVRF(EnergyPlusData &state,
                       state.dataHVACVarRefFlow->MaxCoolingCapacity(VRFCond),
                       state.dataHVACVarRefFlow->VRF(this->VRFSysNum).VRFCondCyclingRatio);
         } else { // cooling coil is off
-            SimDXCoil(state, "", HVAC::CompressorOp::Off, FirstHVACIteration, this->CoolCoilIndex, fanOp, 0.0, OnOffAirFlowRatio);
+            SimDXCoil(state, this->CoolCoilName, HVAC::CompressorOp::Off, FirstHVACIteration, this->CoolCoilNum, fanOp, 0.0, OnOffAirFlowRatio);
         }
         state.dataHVACVarRefFlow->LoopDXCoolCoilRTF = state.dataAirLoop->LoopDXCoilRTF;
     } else {
@@ -9476,17 +8966,17 @@ void VRFTerminalUnitEquipment::CalcVRF(EnergyPlusData &state,
             (state.dataHVACVarRefFlow->VRF(VRFCond).HeatRecoveryUsed &&
              state.dataHVACVarRefFlow->TerminalUnitList(TUListIndex).HRHeatRequest(IndexToTUInTUList))) {
             SimDXCoil(state,
-                      "",
+                      this->HeatCoilName,
                       HVAC::CompressorOp::Off,
                       FirstHVACIteration,
-                      this->HeatCoilIndex,
+                      this->HeatCoilNum,
                       fanOp,
                       PartLoadRatio,
                       OnOffAirFlowRatio,
                       _,
                       state.dataHVACVarRefFlow->MaxHeatingCapacity(VRFCond));
         } else {
-            SimDXCoil(state, "", HVAC::CompressorOp::Off, FirstHVACIteration, this->HeatCoilIndex, fanOp, 0.0, OnOffAirFlowRatio, _);
+            SimDXCoil(state, this->HeatCoilName, HVAC::CompressorOp::Off, FirstHVACIteration, this->HeatCoilNum, fanOp, 0.0, OnOffAirFlowRatio, _);
         }
         state.dataHVACVarRefFlow->LoopDXHeatCoilRTF = state.dataAirLoop->LoopDXCoilRTF;
     } else {
@@ -10874,8 +10364,8 @@ void VRFTerminalUnitEquipment::CalcVRFIUVariableTeTc(EnergyPlusData &state,
     Real64 W_TU_in;              // Air humidity ratio at the indoor unit inlet[kg/kg]
 
     // Get the equipment/zone index corresponding to the VRFTU
-    CoolCoilNum = this->CoolCoilIndex;
-    HeatCoilNum = this->HeatCoilIndex;
+    CoolCoilNum = this->CoolCoilNum;
+    HeatCoilNum = this->HeatCoilNum;
     VRFNum = this->VRFSysNum;
     TUListIndex = state.dataHVACVarRefFlow->VRF(VRFNum).ZoneTUListPtr;
     IndexToTUInTUList = this->IndexToTUInTUList;
@@ -11164,8 +10654,8 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state, c
     // loop through TU's and calculate average inlet conditions for active coils
     for (NumTU = 1; NumTU <= NumTUInList; ++NumTU) {
         TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-        CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex;
-        HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex;
+        CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum;
+        HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilNum;
 
         if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) > 0.0) {
             SumCoolInletWB += state.dataDXCoils->DXCoilCoolInletAirWBTemp(CoolCoilIndex) *
@@ -11302,7 +10792,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state, c
                 for (NumTU = 1; NumTU <= NumTUInList; NumTU++) { // Calc total refrigerant flow rate
                     if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) > 0) {
                         TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-                        CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex;
+                        CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum;
 
                         RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName);
                         h_IU_evap_out_i = this->refrig->getSupHeatEnthalpy(
@@ -11488,7 +10978,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state, c
                 for (NumTU = 1; NumTU <= NumTUInList; NumTU++) {
                     if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) > 0) {
                         TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-                        HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex;
+                        HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilNum;
                         h_IU_cond_out_i =
                             this->refrig->getSatEnthalpy(state,
                                                          this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) -
@@ -11711,7 +11201,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state, c
             for (NumTU = 1; NumTU <= NumTUInList; NumTU++) {
                 if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalHeatLoad(NumTU) > 0) {
                     TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-                    HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex;
+                    HeatCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilNum;
                     h_IU_cond_out_i =
                         this->refrig->getSatEnthalpy(state,
                                                      this->refrig->getSatTemperature(state, max(min(Pcond, RefPHigh), RefPLow), RoutineName) -
@@ -11755,7 +11245,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state, c
             for (NumTU = 1; NumTU <= NumTUInList; NumTU++) { // Calc total refrigerant flow rate
                 if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) > 0) {
                     TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-                    CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex;
+                    CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum;
 
                     RefTSat = this->refrig->getSatTemperature(state, max(min(Pevap, RefPHigh), RefPLow), RoutineName);
                     h_IU_evap_out_i =
@@ -12272,7 +11762,7 @@ void VRFCondenserEquipment::CalcVRFCondenser_FluidTCtrl(EnergyPlusData &state, c
     // update coil and IU evaporating temperature, also keep coil RTF updated with the condenser side cycling ratio, for the FluidTCtrl model
     for (int VRFTUNum = 1; VRFTUNum <= state.dataHVACVarRefFlow->NumVRFTU; ++VRFTUNum) {
         auto const &thisTU = state.dataHVACVarRefFlow->VRFTU(VRFTUNum);
-        auto &coolingCoil = state.dataDXCoils->DXCoil(thisTU.CoolCoilIndex);
+        auto &coolingCoil = state.dataDXCoils->DXCoil(thisTU.CoolCoilNum);
         if (this->adjustedTe && (!FirstHVACIteration)) {
             coolingCoil.EvaporatingTemp = this->EvaporatingTemp;
             this->IUEvaporatingTemp = this->EvaporatingTemp;
@@ -12392,11 +11882,11 @@ void VRFTerminalUnitEquipment::ControlVRF_FluidTCtrl(EnergyPlusData &state,
     if (!DXCoolingCoilOprCtrl) PartLoadRatio = 0.0;
     this->CalcVRF_FluidTCtrl(state, VRFTUNum, FirstHVACIteration, PartLoadRatio, FullOutput, OnOffAirFlowRatio, SuppHeatCoilLoad);
     if (this->CoolingCoilPresent) {
-        auto const &thisAirInNode = state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(this->CoolCoilIndex).AirInNode);
+        auto const &thisAirInNode = state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(this->CoolCoilNum).AirInNode);
         this->coilInNodeT = thisAirInNode.Temp;
         this->coilInNodeW = thisAirInNode.HumRat;
     } else {
-        auto const &thisAirInNode = state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(this->HeatCoilIndex).AirInNode);
+        auto const &thisAirInNode = state.dataLoopNodes->Node(state.dataDXCoils->DXCoil(this->HeatCoilNum).AirInNode);
         this->coilInNodeT = thisAirInNode.Temp;
         this->coilInNodeW = thisAirInNode.HumRat;
     }
@@ -12719,10 +12209,10 @@ void VRFTerminalUnitEquipment::CalcVRF_FluidTCtrl(EnergyPlusData &state,
             (state.dataHVACVarRefFlow->VRF(VRFCond).HeatRecoveryUsed &&
              state.dataHVACVarRefFlow->TerminalUnitList(TUListIndex).HRCoolRequest(IndexToTUInTUList))) {
             SimDXCoil(state,
-                      "",
+                      this->CoolCoilName,
                       HVAC::CompressorOp::On,
                       FirstHVACIteration,
-                      this->CoolCoilIndex,
+                      this->CoolCoilNum,
                       fanOp,
                       PartLoadRatio,
                       _,
@@ -12730,7 +12220,7 @@ void VRFTerminalUnitEquipment::CalcVRF_FluidTCtrl(EnergyPlusData &state,
                       state.dataHVACVarRefFlow->MaxCoolingCapacity(VRFCond),
                       state.dataHVACVarRefFlow->VRF(this->VRFSysNum).VRFCondCyclingRatio);
         } else { // cooling coil is off
-            SimDXCoil(state, "", HVAC::CompressorOp::Off, FirstHVACIteration, this->CoolCoilIndex, fanOp, 0.0, _);
+            SimDXCoil(state, this->CoolCoilName, HVAC::CompressorOp::Off, FirstHVACIteration, this->CoolCoilNum, fanOp, 0.0, _);
         }
         state.dataHVACVarRefFlow->LoopDXCoolCoilRTF = state.dataAirLoop->LoopDXCoilRTF;
     } else {
@@ -12743,17 +12233,17 @@ void VRFTerminalUnitEquipment::CalcVRF_FluidTCtrl(EnergyPlusData &state,
             (state.dataHVACVarRefFlow->VRF(VRFCond).HeatRecoveryUsed &&
              state.dataHVACVarRefFlow->TerminalUnitList(TUListIndex).HRHeatRequest(IndexToTUInTUList))) {
             SimDXCoil(state,
-                      "",
+                      this->HeatCoilName,
                       HVAC::CompressorOp::On,
                       FirstHVACIteration,
-                      this->HeatCoilIndex,
+                      this->HeatCoilNum,
                       fanOp,
                       PartLoadRatio,
                       _,
                       _,
                       state.dataHVACVarRefFlow->MaxHeatingCapacity(VRFCond));
         } else {
-            SimDXCoil(state, "", HVAC::CompressorOp::Off, FirstHVACIteration, this->HeatCoilIndex, fanOp, 0.0, _);
+            SimDXCoil(state, this->HeatCoilName, HVAC::CompressorOp::Off, FirstHVACIteration, this->HeatCoilNum, fanOp, 0.0, _);
         }
         state.dataHVACVarRefFlow->LoopDXHeatCoilRTF = state.dataAirLoop->LoopDXCoilRTF;
     } else {
@@ -12880,7 +12370,7 @@ Real64 VRFTerminalUnitEquipment::CalVRFTUAirFlowRate_FluidTCtrl(EnergyPlusData &
         (state.dataHVACVarRefFlow->VRF(VRFCond).HeatRecoveryUsed &&
          state.dataHVACVarRefFlow->TerminalUnitList(TUListIndex).HRCoolRequest(IndexToTUInTUList))) {
         // VRF terminal unit is on cooling mode
-        DXCoilNum = this->CoolCoilIndex;
+        DXCoilNum = this->CoolCoilNum;
         QCoilReq = -PartLoadRatio * state.dataDXCoils->DXCoil(DXCoilNum).RatedTotCap(Mode);
         TeTc = state.dataHVACVarRefFlow->VRF(VRFCond).IUEvaporatingTemp;
 
@@ -12892,7 +12382,7 @@ Real64 VRFTerminalUnitEquipment::CalVRFTUAirFlowRate_FluidTCtrl(EnergyPlusData &
                (state.dataHVACVarRefFlow->VRF(VRFCond).HeatRecoveryUsed &&
                 state.dataHVACVarRefFlow->TerminalUnitList(TUListIndex).HRHeatRequest(IndexToTUInTUList))) {
         // VRF terminal unit is on heating mode
-        DXCoilNum = this->HeatCoilIndex;
+        DXCoilNum = this->HeatCoilNum;
         Real64 RatedCapacity = state.dataDXCoils->DXCoil(DXCoilNum).RatedTotCap(Mode);
         if (present(MaxHeatCap)) {
             RatedCapacity = min(MaxHeatCap, RatedCapacity);
@@ -13499,7 +12989,7 @@ void VRFCondenserEquipment::VRFOU_TeModification(
         for (int NumTU = 1; NumTU <= NumTUInList; NumTU++) {
             if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) > 0) {
                 TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-                CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex;
+                CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum;
 
                 // The IU coil surface temperature should be the same.
                 Tfs = Te_up + (this->C3Te * pow_2(state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH) +
@@ -14059,7 +13549,7 @@ void VRFCondenserEquipment::VRFOU_CalcCompC(EnergyPlusData &state,
                             for (int NumTU = 1; NumTU <= NumTUInList; NumTU++) {
                                 if (state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).TotalCoolLoad(NumTU) > 0) {
                                     TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-                                    CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex;
+                                    CoolCoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum;
 
                                     Tfs = this->EvaporatingTemp + (this->C3Te * pow_2(state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH) +
                                                                    this->C2Te * state.dataDXCoils->DXCoil(CoolCoilIndex).ActualSH + this->C1Te);
@@ -14915,7 +14405,7 @@ void VRFCondenserEquipment::VRFOU_PipeLossC(
     NumIUActivated = 0;
     for (int NumTU = 1; NumTU <= NumTUInList; ++NumTU) {
         int TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-        int CoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilIndex;
+        int CoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).CoolCoilNum;
 
         if (state.dataDXCoils->DXCoil(CoilIndex).TotalCoolingEnergyRate > 0.0) {
             Pipe_T_room = Pipe_T_room + state.dataDXCoils->DXCoil(CoilIndex).InletAirTemp;
@@ -15068,7 +14558,7 @@ void VRFCondenserEquipment::VRFOU_PipeLossH(
     NumIUActivated = 0;
     for (int NumTU = 1; NumTU <= NumTUInList; ++NumTU) {
         int TUIndex = state.dataHVACVarRefFlow->TerminalUnitList(TUListNum).ZoneTUPtr(NumTU);
-        int CoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilIndex;
+        int CoilIndex = state.dataHVACVarRefFlow->VRFTU(TUIndex).HeatCoilNum;
 
         if (state.dataDXCoils->DXCoil(CoilIndex).TotalHeatingEnergyRate > 0.0) {
             Pipe_T_room = Pipe_T_room + state.dataDXCoils->DXCoil(CoilIndex).InletAirTemp;
@@ -15157,21 +14647,21 @@ void VRFTerminalUnitEquipment::CalcVRFSuppHeatingCoil(EnergyPlusData &state,
         SuppHeatCoilLoad = 0.0;
     }
 
-    switch (this->SuppHeatCoilType_Num) {
-    case HVAC::Coil_HeatingGasOrOtherFuel:
-    case HVAC::Coil_HeatingElectric: {
+    switch (this->suppHeatCoilType) {
+    case HVAC::CoilType::HeatingGasOrOtherFuel:
+    case HVAC::CoilType::HeatingElectric: {
         HeatingCoils::SimulateHeatingCoilComponents(
-            state, this->SuppHeatCoilName, FirstHVACIteration, SuppHeatCoilLoad, this->SuppHeatCoilIndex, QActual, true, this->fanOp, PartLoadRatio);
+            state, this->SuppHeatCoilName, FirstHVACIteration, SuppHeatCoilLoad, this->SuppHeatCoilNum, QActual, true, this->fanOp, PartLoadRatio);
         SuppHeatCoilLoad = QActual;
     } break;
-    case HVAC::Coil_HeatingWater: {
+    case HVAC::CoilType::HeatingWater: {
         if (SuppHeatCoilLoad > HVAC::SmallLoad) {
             //     see if HW coil has enough capacity to meet the load
             Real64 mdot = this->SuppHeatCoilFluidMaxFlow;
             state.dataLoopNodes->Node(this->SuppHeatCoilFluidInletNode).MassFlowRate = mdot;
             //     simulate hot water coil to find the full flow operating capacity
             WaterCoils::SimulateWaterCoilComponents(
-                state, this->SuppHeatCoilName, FirstHVACIteration, this->SuppHeatCoilIndex, QActual, this->fanOp, PartLoadRatio);
+                state, this->SuppHeatCoilName, FirstHVACIteration, this->SuppHeatCoilNum, QActual, this->fanOp, PartLoadRatio);
             if (QActual > SuppHeatCoilLoad) {
                 int SolFla; // Flag of solver, num iterations if >0, else error index
                 auto f = [&state, VRFTUNum, FirstHVACIteration, SuppHeatCoilLoad](Real64 const PartLoadFrac) {
@@ -15181,7 +14671,7 @@ void VRFTerminalUnitEquipment::CalcVRFSuppHeatingCoil(EnergyPlusData &state,
                     WaterCoils::SimulateWaterCoilComponents(state,
                                                             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
                                                             FirstHVACIteration,
-                                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex,
+                                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum,
                                                             QActual,
                                                             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).fanOp,
                                                             PartLoadFrac);
@@ -15206,14 +14696,14 @@ void VRFTerminalUnitEquipment::CalcVRFSuppHeatingCoil(EnergyPlusData &state,
         }
         //     simulate water heating coil
         WaterCoils::SimulateWaterCoilComponents(
-            state, this->SuppHeatCoilName, FirstHVACIteration, this->SuppHeatCoilIndex, SuppHeatCoilLoad, this->fanOp, this->SuppHeatPartLoadRatio);
+            state, this->SuppHeatCoilName, FirstHVACIteration, this->SuppHeatCoilNum, SuppHeatCoilLoad, this->fanOp, this->SuppHeatPartLoadRatio);
     } break;
-    case HVAC::Coil_HeatingSteam: {
+    case HVAC::CoilType::HeatingSteam: {
         //     simulate steam heating coil
         Real64 mdot = this->SuppHeatCoilFluidMaxFlow * PartLoadRatio;
         state.dataLoopNodes->Node(this->SuppHeatCoilFluidInletNode).MassFlowRate = mdot;
         SteamCoils::SimulateSteamCoilComponents(
-            state, this->SuppHeatCoilName, FirstHVACIteration, this->SuppHeatCoilIndex, SuppHeatCoilLoad, QActual, this->fanOp, PartLoadRatio);
+            state, this->SuppHeatCoilName, FirstHVACIteration, this->SuppHeatCoilNum, SuppHeatCoilLoad, QActual, this->fanOp, PartLoadRatio);
         SuppHeatCoilLoad = QActual;
     } break;
     default:
@@ -15223,6 +14713,7 @@ void VRFTerminalUnitEquipment::CalcVRFSuppHeatingCoil(EnergyPlusData &state,
     SuppCoilLoad = SuppHeatCoilLoad;
 }
 
+// We're still doing this dance?
 Real64 VRFTerminalUnitEquipment::HotWaterHeatingCoilResidual(EnergyPlusData &state,
                                                              Real64 const PartLoadFrac,     // water heating coil part-load ratio
                                                              std::vector<Real64> const &Par // par(1) = index to current VRF terminal unit
@@ -15255,7 +14746,7 @@ Real64 VRFTerminalUnitEquipment::HotWaterHeatingCoilResidual(EnergyPlusData &sta
     WaterCoils::SimulateWaterCoilComponents(state,
                                             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName,
                                             FirstHVACIteration,
-                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilIndex,
+                                            state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilNum,
                                             QActual,
                                             state.dataHVACVarRefFlow->VRFTU(VRFTUNum).fanOp,
                                             PartLoadFrac);
diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh
index 70f85927ad8..c75a0aaf250 100644
--- a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh
+++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh
@@ -685,17 +685,22 @@ namespace HVACVariableRefrigerantFlow {
         HVAC::FanOp fanOp = HVAC::FanOp::Invalid;          // operation mode: 1 = cycling fan, cycling coil 2 = constant fan, cycling coil
         HVAC::FanPlace fanPlace = HVAC::FanPlace::Invalid; // fan placement; 1=blow through, 2=draw through
         Real64 ActualFanVolFlowRate = 0.0;                 // volumetric flow rate from fan object
-        std::string SuppHeatCoilType;                      // type of supplemental heating coil
-        std::string SuppHeatCoilName;                      // name of supplemental heating coil
         std::string OAMixerName;                           // name of outside air mixer
         int OAMixerIndex = 0;                              // index to outside air mixer
         bool OAMixerUsed = false;                          // true if OA Mixer object is used
-        int CoolCoilIndex = 0;                             // index to terminal unit cooling coil
-        int HeatCoilIndex = 0;                             // index to terminal unit heating coil
-        int SuppHeatCoilIndex = 0;                         // index to terminal unit supplemental heating coil
-        int DXCoolCoilType_Num = 0;                        // type of VRF cooling coil
-        int DXHeatCoilType_Num = 0;                        // type of VRF heating coil
-        int SuppHeatCoilType_Num = 0;                      // type of VRF supplemental heating coil
+
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;                        // type of VRF cooling coil
+        std::string CoolCoilName;                      // name of supplemental heating coil
+        int CoolCoilNum = 0;                             // index to terminal unit cooling coil
+
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;                        // type of VRF heating coil
+        std::string HeatCoilName;                      // name of supplemental heating coil
+        int HeatCoilNum = 0;                             // index to terminal unit heating coil
+
+        HVAC::CoilType suppHeatCoilType = HVAC::CoilType::Invalid;                      // type of VRF supplemental heating coil
+        std::string SuppHeatCoilName;                      // name of supplemental heating coil
+        int SuppHeatCoilNum = 0;                         // index to terminal unit supplemental heating coil
+
         Real64 ParasiticElec = 0.0;                        // parasitic electric for VRF terminal unit
         Real64 ParasiticOffElec = 0.0;                     // parasitic electric for VRF terminal unit when off
         Real64 HeatingSpeedRatio = 1.0;                    // Fan speed ratio in heating mode
diff --git a/src/EnergyPlus/HeatBalanceManager.cc b/src/EnergyPlus/HeatBalanceManager.cc
index 015c1bec8cf..a79de587762 100644
--- a/src/EnergyPlus/HeatBalanceManager.cc
+++ b/src/EnergyPlus/HeatBalanceManager.cc
@@ -5519,12 +5519,13 @@ namespace HeatBalanceManager {
 
                 if (NumRows != NBasis) {
                     ErrorsFound = true;
-                    ShowSevereCustom(state,
-                                     eoh,
-                                     format("Visible back reflectance matrix \"{}\" is not the same size as it is defined by basis definition. Basis "
-                                            "size is defined by Matrix:TwoDimension = \"{}\".",
-                                            locAlphaArgs(9),
-                                            locAlphaArgs(5)));
+                    ShowSevereCustom(
+                        state,
+                        eoh,
+                        format("Visible back reflectance matrix \"{}\" is not the same size as it is defined by basis definition. Basis "
+                               "size is defined by Matrix:TwoDimension = \"{}\".",
+                               locAlphaArgs(9),
+                               locAlphaArgs(5)));
                 }
 
                 if (NumRows != NumCols) {
@@ -5573,26 +5574,28 @@ namespace HeatBalanceManager {
 
                         if (NumCols != NBasis) {
                             ErrorsFound = true;
-                            ShowSevereCustom(state,
-                                             eoh,
-                                             format("Front absorbtance Matrix:TwoDimension = \"{}\" for layer {} must have same number of columns "
-                                                    "as it is defined by basis matrix."
-                                                    "Matrix has {} number of columns, while basis definition specifies {} number of columns.",
-                                                    locAlphaArgs(AlphaIndex),
-                                                    currentOpticalLayer,
-                                                    NumCols,
-                                                    NBasis));
+                            ShowSevereCustom(
+                                state,
+                                eoh,
+                                format("Front absorbtance Matrix:TwoDimension = \"{}\" for layer {} must have same number of columns "
+                                       "as it is defined by basis matrix."
+                                       "Matrix has {} number of columns, while basis definition specifies {} number of columns.",
+                                       locAlphaArgs(AlphaIndex),
+                                       currentOpticalLayer,
+                                       NumCols,
+                                       NBasis));
                         }
 
                         thisConstruct.BSDFInput.Layer(currentOpticalLayer).AbsNcols = NumCols;
                         thisConstruct.BSDFInput.Layer(currentOpticalLayer).FrtAbs.allocate(NumCols, NumRows);
                         if (thisConstruct.BSDFInput.Layer(currentOpticalLayer).FrtAbsIndex == 0) {
                             ErrorsFound = true;
-                            ShowSevereCustom(state,
-                                             eoh,
-                                             format("Front absorbtance Matrix:TwoDimension = \"{}\" for layer {} is missing from the input file.",
-                                                    locAlphaArgs(AlphaIndex),
-                                                    currentOpticalLayer));
+                            ShowSevereCustom(
+                                state,
+                                eoh,
+                                format("Front absorbtance Matrix:TwoDimension = \"{}\" for layer {} is missing from the input file.",
+                                       locAlphaArgs(AlphaIndex),
+                                       currentOpticalLayer));
                         } else {
                             MatrixDataManager::Get2DMatrix(state,
                                                            thisConstruct.BSDFInput.Layer(currentOpticalLayer).FrtAbsIndex,
@@ -5619,25 +5622,27 @@ namespace HeatBalanceManager {
 
                         if (NumCols != NBasis) {
                             ErrorsFound = true;
-                            ShowSevereCustom(state,
-                                             eoh,
-                                             format("Back absorbtance Matrix:TwoDimension = \"{}\" for layer {} must have same number of columns as "
-                                                    "it is defined by basis matrix."
-                                                    "Matrix has {} number of columns, while basis definition specifies {} number of columns.",
-                                                    locAlphaArgs(AlphaIndex),
-                                                    currentOpticalLayer,
-                                                    NumCols,
-                                                    NBasis));
+                            ShowSevereCustom(
+                                state,
+                                eoh,
+                                format("Back absorbtance Matrix:TwoDimension = \"{}\" for layer {} must have same number of columns as "
+                                       "it is defined by basis matrix."
+                                       "Matrix has {} number of columns, while basis definition specifies {} number of columns.",
+                                       locAlphaArgs(AlphaIndex),
+                                       currentOpticalLayer,
+                                       NumCols,
+                                       NBasis));
                         }
 
                         thisConstruct.BSDFInput.Layer(currentOpticalLayer).BkAbs.allocate(NumCols, NumRows);
                         if (thisConstruct.BSDFInput.Layer(currentOpticalLayer).BkAbsIndex == 0) {
                             ErrorsFound = true;
-                            ShowSevereCustom(state,
-                                             eoh,
-                                             format("Back absorbtance Matrix:TwoDimension = \"{}\" for layer {} is missing from the input file.",
-                                                    locAlphaArgs(AlphaIndex),
-                                                    currentOpticalLayer));
+                            ShowSevereCustom(
+                                state,
+                                eoh,
+                                format("Back absorbtance Matrix:TwoDimension = \"{}\" for layer {} is missing from the input file.",
+                                       locAlphaArgs(AlphaIndex),
+                                       currentOpticalLayer));
                         } else {
                             MatrixDataManager::Get2DMatrix(state,
                                                            thisConstruct.BSDFInput.Layer(currentOpticalLayer).BkAbsIndex,
diff --git a/src/EnergyPlus/HeatRecovery.cc b/src/EnergyPlus/HeatRecovery.cc
index f2b98a7a1ce..4632e3af722 100644
--- a/src/EnergyPlus/HeatRecovery.cc
+++ b/src/EnergyPlus/HeatRecovery.cc
@@ -120,7 +120,7 @@ namespace HeatRecovery {
                          ObjexxFCL::Optional_bool_const RegenInletIsOANode,  // flag to determine if supply inlet is OA node, if so air flow cycles
                          ObjexxFCL::Optional_bool_const EconomizerFlag,      // economizer operation flag passed by airloop or OA sys
                          ObjexxFCL::Optional_bool_const HighHumCtrlFlag,     // high humidity control flag passed by airloop or OA sys
-                         ObjexxFCL::Optional_int_const CompanionCoilType_Num // cooling coil type of coil
+                         ObjexxFCL::Optional<HVAC::CoilType> companionCoilType // cooling coil type of coil
     )
     {
 
@@ -168,8 +168,6 @@ namespace HeatRecovery {
         }
 
         int CompanionCoilNum = present(CompanionCoilIndex) ? int(CompanionCoilIndex) : -1; // Index to companion cooling coil
-        int companionCoilType = present(CompanionCoilType_Num) ? int(CompanionCoilType_Num) : -1;
-
         bool HXUnitOn; // flag to enable heat exchanger
         if (present(HXUnitEnable)) {
             HXUnitOn = HXUnitEnable;
@@ -190,7 +188,7 @@ namespace HeatRecovery {
 
         auto &thisExch = state.dataHeatRecovery->ExchCond(HeatExchNum);
 
-        thisExch.initialize(state, CompanionCoilNum, companionCoilType);
+        thisExch.initialize(state, CompanionCoilNum, present(companionCoilType) ? companionCoilType() : HVAC::CoilType::Invalid);
 
         // call the correct heat exchanger calculation routine
         switch (state.dataHeatRecovery->ExchCond(HeatExchNum).type) {
@@ -1176,7 +1174,7 @@ namespace HeatRecovery {
         }
     }
 
-    void HeatExchCond::initialize(EnergyPlusData &state, int const CompanionCoilIndex, int const CompanionCoilType_Num)
+    void HeatExchCond::initialize(EnergyPlusData &state, int const CompanionCoilIndex, HVAC::CoilType const companionCoilType)
     {
 
         // SUBROUTINE INFORMATION:
@@ -1460,10 +1458,12 @@ namespace HeatRecovery {
             }
 
             if ((CompanionCoilIndex > -1) &&
-                ((CompanionCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) || (CompanionCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
-                 (CompanionCoilType_Num == HVAC::CoilDX_Cooling))) {
+                (companionCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                 companionCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                 companionCoilType == HVAC::CoilType::CoolingDX)) {
 
-                if (CompanionCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || CompanionCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+                if (companionCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                    companionCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                     if (state.dataDXCoils->DXCoilFullLoadOutAirTemp(CompanionCoilIndex) == 0.0 ||
                         state.dataDXCoils->DXCoilFullLoadOutAirHumRat(CompanionCoilIndex) == 0.0) {
                         //       DX Coil is OFF, read actual inlet conditions
@@ -1474,11 +1474,11 @@ namespace HeatRecovery {
                         state.dataHeatRecovery->FullLoadOutAirTemp = state.dataDXCoils->DXCoilFullLoadOutAirTemp(CompanionCoilIndex);
                         state.dataHeatRecovery->FullLoadOutAirHumRat = state.dataDXCoils->DXCoilFullLoadOutAirHumRat(CompanionCoilIndex);
                     }
-                } else if (CompanionCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                } else if (companionCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     // how to support VS dx coil here?
                     state.dataHeatRecovery->FullLoadOutAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(CompanionCoilIndex).OutletAirDBTemp;
                     state.dataHeatRecovery->FullLoadOutAirHumRat = state.dataVariableSpeedCoils->VarSpeedCoil(CompanionCoilIndex).OutletAirHumRat;
-                } else if (CompanionCoilType_Num == HVAC::CoilDX_Cooling) {
+                } else if (companionCoilType == HVAC::CoilType::CoolingDX) {
                     // Use the new coil option:
                     state.dataHeatRecovery->FullLoadOutAirTemp = state.dataCoilCoolingDX->coilCoolingDXs[CompanionCoilIndex].outletAirDryBulbTemp;
                     state.dataHeatRecovery->FullLoadOutAirHumRat = state.dataCoilCoolingDX->coilCoolingDXs[CompanionCoilIndex].outletAirHumRat;
@@ -2380,7 +2380,7 @@ namespace HeatRecovery {
         HVAC::FanOp const fanOp,                       // Supply air fan operating mode (1=cycling, 2=constant)
         Real64 const PartLoadRatio,                    // Part load ratio requested of DX compressor
         int const CompanionCoilIndex,                  // index of companion cooling coil
-        int const CompanionCoilType,                   // type of cooling coil
+        HVAC::CoilType const companionCoilType,                   // type of cooling coil
         bool const RegenInletIsOANode,                 // Flag to determine if regen side inlet is OANode, if so this air stream cycles
         ObjexxFCL::Optional_bool_const EconomizerFlag, // economizer flag pass by air loop or OA sys
         ObjexxFCL::Optional_bool_const HighHumCtrlFlag // high humidity control flag passed by airloop or OA sys
@@ -2607,10 +2607,11 @@ namespace HeatRecovery {
                 HXPartLoadRatio = max(0.0, HXPartLoadRatio);
                 HXPartLoadRatio = min(1.0, HXPartLoadRatio);
 
-            } else if (CompanionCoilType > 0 && CompanionCoilIndex > -1) {
-                if (CompanionCoilType == HVAC::CoilDX_Cooling) {
+
+            } else if (companionCoilType != HVAC::CoilType::Invalid && CompanionCoilIndex > -1) {
+                if (companionCoilType == HVAC::CoilType::CoolingDX) {
                     HXPartLoadRatio = state.dataCoilCoolingDX->coilCoolingDXs[CompanionCoilIndex].partLoadRatioReport;
-                } else if (CompanionCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                } else if (companionCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     HXPartLoadRatio = state.dataVariableSpeedCoils->VarSpeedCoil(CompanionCoilIndex).PartLoadRatio;
                 } else {
                     HXPartLoadRatio = state.dataDXCoils->DXCoilPartLoadRatio(CompanionCoilIndex);
@@ -4764,197 +4765,120 @@ namespace HeatRecovery {
         }
     }
 
-    int GetSupplyInletNode(EnergyPlusData &state,
-                           std::string const &HXName, // must match HX names for the state.dataHeatRecovery->ExchCond type
-                           bool &ErrorsFound          // set to true if problem
-    )
-    {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   February 2007
-        //       MODIFIED       na
-        //       RE-ENGINEERED  na
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given HX and returns the supply air inlet node number.
-        // If incorrect HX name is given, ErrorsFound is returned as true and node number as zero.
-
+    int GetHeatExchangerIndex(EnergyPlusData &state, std::string const &hxName, bool &ErrorsFound) {
         // Obtains and Allocates heat exchanger related parameters from input file
         if (state.dataHeatRecovery->GetInputFlag) { // First time subroutine has been entered
             GetHeatRecoveryInput(state);
             state.dataHeatRecovery->GetInputFlag = false;
         }
 
-        int const WhichHX = Util::FindItemInList(HXName, state.dataHeatRecovery->ExchCond);
-        if (WhichHX != 0) {
-            return state.dataHeatRecovery->ExchCond(WhichHX).SupInletNode;
-        } else {
-            ShowSevereError(state, format("GetSupplyInletNode: Could not find heat exchanger = \"{}\"", HXName));
+        int hxNum = Util::FindItemInList(hxName, state.dataHeatRecovery->ExchCond);
+        if (hxNum == 0) {
+            ShowSevereError(state, format("GetHeatExchangerIndex: Could not find heat exchanger = \"{}\"", hxName));
             ErrorsFound = true;
-            return 0;
         }
+        return hxNum;
     }
 
-    int GetSupplyOutletNode(EnergyPlusData &state,
-                            std::string const &HXName, // must match HX names for the state.dataHeatRecovery->ExchCond type
-                            bool &ErrorsFound          // set to true if problem
+    int GetSupplyInletNode(EnergyPlusData &state,
+                           std::string const &hxName, 
+                           bool &ErrorsFound          
     )
     {
+        int hxNum = GetHeatExchangerIndex(state, hxName, ErrorsFound);
+        return (hxNum == 0) ? 0 : state.dataHeatRecovery->ExchCond(hxNum).SupInletNode;
+    }
 
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   February 2007
-        //       MODIFIED       na
-        //       RE-ENGINEERED  na
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given HX and returns the supply air outlet node number.
-        // If incorrect HX name is given, ErrorsFound is returned as true and node number as zero.
-
-        // Obtains and Allocates heat exchanger related parameters from input file
-        if (state.dataHeatRecovery->GetInputFlag) { // First time subroutine has been entered
-            GetHeatRecoveryInput(state);
-            state.dataHeatRecovery->GetInputFlag = false;
-        }
-
-        int const WhichHX = Util::FindItemInList(HXName, state.dataHeatRecovery->ExchCond);
-        if (WhichHX != 0) {
-            return state.dataHeatRecovery->ExchCond(WhichHX).SupOutletNode;
-        } else {
-            ShowSevereError(state, format("GetSupplyOutletNode: Could not find heat exchanger = \"{}\"", HXName));
-            ErrorsFound = true;
-            return 0;
-        }
+    int GetSupplyOutletNode(EnergyPlusData &state,
+                            std::string const &hxName,
+                            bool &ErrorsFound    
+    )
+    {
+        int hxNum = GetHeatExchangerIndex(state, hxName, ErrorsFound);
+        return (hxNum == 0) ? 0 : state.dataHeatRecovery->ExchCond(hxNum).SupOutletNode;
     }
 
     int GetSecondaryInletNode(EnergyPlusData &state,
-                              std::string const &HXName, // must match HX names for the state.dataHeatRecovery->ExchCond type
+                              std::string const &hxName, // must match HX names for the state.dataHeatRecovery->ExchCond type
                               bool &ErrorsFound          // set to true if problem
     )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   February 2007
-        //       MODIFIED       na
-        //       RE-ENGINEERED  na
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given HX and returns the secondary air inlet node number.
-        // If incorrect HX name is given, ErrorsFound is returned as true and node number as zero.
-
-        // Obtains and Allocates heat exchanger related parameters from input file
-        if (state.dataHeatRecovery->GetInputFlag) { // First time subroutine has been entered
-            GetHeatRecoveryInput(state);
-            state.dataHeatRecovery->GetInputFlag = false;
-        }
-
-        int const WhichHX = Util::FindItemInList(HXName, state.dataHeatRecovery->ExchCond);
-        if (WhichHX != 0) {
-            return state.dataHeatRecovery->ExchCond(WhichHX).SecInletNode;
-        } else {
-            ShowSevereError(state, format("GetSecondaryInletNode: Could not find heat exchanger = \"{}\"", HXName));
-            ErrorsFound = true;
-            return 0;
-        }
+        int hxNum = GetHeatExchangerIndex(state, hxName, ErrorsFound);
+        return (hxNum == 0) ? 0 : state.dataHeatRecovery->ExchCond(hxNum).SecInletNode;
     }
 
     int GetSecondaryOutletNode(EnergyPlusData &state,
-                               std::string const &HXName, // must match HX names for the state.dataHeatRecovery->ExchCond type
+                               std::string const &hxName, // must match HX names for the state.dataHeatRecovery->ExchCond type
                                bool &ErrorsFound          // set to true if problem
     )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   February 2007
-        //       MODIFIED       na
-        //       RE-ENGINEERED  na
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given HX assisted cooling coil and returns the secondary air outlet node number.
-        // If incorrect HX name is given, ErrorsFound is returned as true and node number as zero.
-
-        // Obtains and Allocates heat exchanger related parameters from input file
-        if (state.dataHeatRecovery->GetInputFlag) { // First time subroutine has been entered
-            GetHeatRecoveryInput(state);
-            state.dataHeatRecovery->GetInputFlag = false;
-        }
-
-        int const WhichHX = Util::FindItemInList(HXName, state.dataHeatRecovery->ExchCond);
-        if (WhichHX != 0) {
-            return state.dataHeatRecovery->ExchCond(WhichHX).SecOutletNode;
-        } else {
-            ShowSevereError(state, format("GetSecondaryOutletNode: Could not find heat exchanger = \"{}\"", HXName));
-            ErrorsFound = true;
-            return 0;
-        }
+        int hxNum = GetHeatExchangerIndex(state, hxName, ErrorsFound);
+        return (hxNum == 0) ? 0 : state.dataHeatRecovery->ExchCond(hxNum).SecOutletNode;
     }
 
     Real64 GetSupplyAirFlowRate(EnergyPlusData &state,
-                                std::string const &HXName, // must match HX names for the state.dataHeatRecovery->ExchCond type
+                                std::string const &hxName, // must match HX names for the state.dataHeatRecovery->ExchCond type
                                 bool &ErrorsFound          // set to true if problem
     )
     {
+        int hxNum = GetHeatExchangerIndex(state, hxName, ErrorsFound);
+        return (hxNum == 0) ? 0.0 : state.dataHeatRecovery->ExchCond(hxNum).NomSupAirVolFlow;
+    }
 
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   October 2007
-        //       MODIFIED       na
-        //       RE-ENGINEERED  na
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given Generic HX and the volumetric air flow rate.
-        // If incorrect HX name is given, ErrorsFound is returned as true and air flow rate as zero.
+    HVAC::HXType GetHeatExchangerType(EnergyPlusData &state,
+                                      std::string const &hxName, // must match HX names for the state.dataHeatRecovery->ExchCond type
+                                      bool &ErrorsFound          // set to true if problem
+    )
+    {
+        int hxNum = GetHeatExchangerIndex(state, hxName, ErrorsFound);
+        return (hxNum == 0) ? HVAC::HXType::Invalid : state.dataHeatRecovery->ExchCond(hxNum).type;
+    }
 
+    int GetHeatExchangerIndex(EnergyPlusData &state, std::string const &hxName) {
         // Obtains and Allocates heat exchanger related parameters from input file
-        if (state.dataHeatRecovery->GetInputFlag) { // First time subroutine has been entered
+        if (state.dataHeatRecovery->GetInputFlag) { 
             GetHeatRecoveryInput(state);
             state.dataHeatRecovery->GetInputFlag = false;
         }
 
-        int const WhichHX = Util::FindItemInList(HXName, state.dataHeatRecovery->ExchCond);
-        if (WhichHX != 0) {
-            return state.dataHeatRecovery->ExchCond(WhichHX).NomSupAirVolFlow;
-        } else {
-            ShowSevereError(state, format("GetSupplyAirFlowRate: Could not find heat exchanger = \"{}\"", HXName));
-            ShowContinueError(state, "... Supply Air Flow Rate returned as 0.");
-            ErrorsFound = true;
-            return 0.0;
-        }
+        return Util::FindItemInList(hxName, state.dataHeatRecovery->ExchCond);
+    }
+  
+    int GetSupplyInletNode(EnergyPlusData &state, int const hxNum)
+    {
+        assert(hxNum > 0 && hxNum <= state.dataHeatRecovery->NumHeatExchangers);
+        return state.dataHeatRecovery->ExchCond(hxNum).SupInletNode;
     }
 
-    HVAC::HXType GetHeatExchangerObjectTypeNum(EnergyPlusData &state,
-                                               std::string const &HXName, // must match HX names for the state.dataHeatRecovery->ExchCond type
-                                               bool &ErrorsFound          // set to true if problem
-    )
+    int GetSupplyOutletNode(EnergyPlusData &state, int const hxNum)
     {
+        assert(hxNum > 0 && hxNum <= state.dataHeatRecovery->NumHeatExchangers);
+        return state.dataHeatRecovery->ExchCond(hxNum).SupOutletNode;
+    }
 
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   October 2007
-        //       MODIFIED       na
-        //       RE-ENGINEERED  na
 
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given Generic HX and the volumetric air flow rate.
-        // If incorrect HX name is given, ErrorsFound is returned as true and air flow rate as zero.
+    HVAC::HXType GetHeatExchangerType(EnergyPlusData &state, int const hxNum)
+    {
+        assert(hxNum > 0 && hxNum <= state.dataHeatRecovery->NumHeatExchangers);
+        return state.dataHeatRecovery->ExchCond(hxNum).type;
+    }
 
-        // Obtains and Allocates heat exchanger related parameters from input file
-        if (state.dataHeatRecovery->GetInputFlag) { // First time subroutine has been entered
-            GetHeatRecoveryInput(state);
-            state.dataHeatRecovery->GetInputFlag = false;
-        }
+    int GetSecondaryInletNode(EnergyPlusData &state, int const hxNum)
+    {
+        assert(hxNum > 0 && hxNum <= state.dataHeatRecovery->NumHeatExchangers);
+        return state.dataHeatRecovery->ExchCond(hxNum).SecInletNode;
+    }
 
-        int const WhichHX = Util::FindItemInList(HXName, state.dataHeatRecovery->ExchCond);
-        if (WhichHX != 0) {
-            return state.dataHeatRecovery->ExchCond(WhichHX).type;
-        } else {
-            ShowSevereError(state, format("GetHeatExchangerObjectTypeNum: Could not find heat exchanger = \"{}\"", HXName));
-            ErrorsFound = true;
-            return HVAC::HXType::Invalid;
-        }
+    int GetSecondaryOutletNode(EnergyPlusData &state, int const hxNum) 
+    {
+        assert(hxNum > 0 && hxNum <= state.dataHeatRecovery->NumHeatExchangers);
+        return state.dataHeatRecovery->ExchCond(hxNum).SecOutletNode;
+    }
+
+    Real64 GetSupplyAirFlowRate(EnergyPlusData &state, int const hxNum) 
+    {
+        assert(hxNum > 0 && hxNum <= state.dataHeatRecovery->NumHeatExchangers);
+        return state.dataHeatRecovery->ExchCond(hxNum).NomSupAirVolFlow;
     }
 
 } // namespace HeatRecovery
diff --git a/src/EnergyPlus/HeatRecovery.hh b/src/EnergyPlus/HeatRecovery.hh
index 99239ce55fd..09810009fb7 100644
--- a/src/EnergyPlus/HeatRecovery.hh
+++ b/src/EnergyPlus/HeatRecovery.hh
@@ -201,7 +201,7 @@ namespace HeatRecovery {
         bool MySetPointTest = true;
         bool MySizeFlag = true;
 
-        void initialize(EnergyPlusData &state, int CompanionCoilIndex, int CompanionCoilType_Num);
+        void initialize(EnergyPlusData &state, int CompanionCoilIndex, HVAC::CoilType companionCoilType);
 
         void size(EnergyPlusData &state);
 
@@ -227,7 +227,7 @@ namespace HeatRecovery {
                                       HVAC::FanOp const fanOp, // Supply air fan operating mode (1=cycling, 2=constant)
                                       Real64 PartLoadRatio,    // Part load ratio requested of DX compressor
                                       int CompanionCoilIndex,  // index of companion cooling coil
-                                      int CompanionCoilType,   // type of cooling coil
+                                      HVAC::CoilType companionCoilType,   // type of cooling coil
                                       bool RegenInletIsOANode, // Flag to determine if regen side inlet is OANode, if so this air stream cycles
                                       ObjexxFCL::Optional_bool_const EconomizerFlag = _, // economizer flag pass by air loop or OA sys
                                       ObjexxFCL::Optional_bool_const HighHumCtrlFlag = _ // high humidity control flag passed by airloop or OA sys
@@ -401,7 +401,7 @@ namespace HeatRecovery {
                          ObjexxFCL::Optional_bool_const RegenInletIsOANode = _, // flag to determine if supply inlet is OA node, if so air flow cycles
                          ObjexxFCL::Optional_bool_const EconomizerFlag = _,     // economizer operation flag passed by airloop or OA sys
                          ObjexxFCL::Optional_bool_const HighHumCtrlFlag = _,    // high humidity control flag passed by airloop or OA sys
-                         ObjexxFCL::Optional_int_const CompanionCoilType_Num = _ // cooling coil type of coil
+                         ObjexxFCL::Optional<HVAC::CoilType> companionCoilType = _ // cooling coil type of coil
     );
 
     void GetHeatRecoveryInput(EnergyPlusData &state);
@@ -427,6 +427,10 @@ namespace HeatRecovery {
                                          Real64 Z    // capacity rate ratio
     );
 
+    int GetHeatExchangerIndex(EnergyPlusData &state,
+                              std::string const &hxName);
+
+#ifdef OLD_API  
     int GetSupplyInletNode(EnergyPlusData &state,
                            std::string const &HXName, // must match HX names for the ExchCond type
                            bool &ErrorsFound          // set to true if problem
@@ -452,10 +456,24 @@ namespace HeatRecovery {
                                 bool &ErrorsFound          // set to true if problem
     );
 
-    HVAC::HXType GetHeatExchangerObjectTypeNum(EnergyPlusData &state,
-                                               std::string const &HXName, // must match HX names for the ExchCond type
-                                               bool &ErrorsFound          // set to true if problem
-    );
+    HVAC::HXType GetHeatExchangerType(EnergyPlusData &state,
+                                      std::string const &HXName, // must match HX names for the ExchCond type
+                                      bool &ErrorsFound          // set to true if problem
+                                      );
+#endif // OLD_API
+  
+    // New API
+    int GetSupplyInletNode(EnergyPlusData &state, int const hxNum);
+
+    int GetSupplyOutletNode(EnergyPlusData &state, int const hxNum);
+
+    int GetSecondaryInletNode(EnergyPlusData &state, int const hxNum);
+
+    int GetSecondaryOutletNode(EnergyPlusData &state, int const hxNum);
+
+    Real64 GetSupplyAirFlowRate(EnergyPlusData &state, int const hxNum);
+  
+    HVAC::HXType GetHeatExchangerType(EnergyPlusData &state, int const hxNum);
 
 } // namespace HeatRecovery
 
diff --git a/src/EnergyPlus/HeatingCoils.cc b/src/EnergyPlus/HeatingCoils.cc
index 10b2d0f7bb5..9c8808b622f 100644
--- a/src/EnergyPlus/HeatingCoils.cc
+++ b/src/EnergyPlus/HeatingCoils.cc
@@ -166,6 +166,44 @@ namespace HeatingCoils {
             ShowFatalError(state, "Preceding conditions cause termination.");
         }
 
+        SimulateHeatingCoilComponents(state,
+                                      CoilNum,
+                                      FirstHVACIteration,
+                                      QCoilReq, 
+                                      QCoilActual,
+                                      SuppHeat, 
+                                      fanOpMode, 
+                                      PartLoadRatio,
+                                      StageNum,
+                                      SpeedRatio);
+
+    }
+
+    void SimulateHeatingCoilComponents(EnergyPlusData &state,
+                                       int const coilNum,
+                                       bool const FirstHVACIteration,
+                                       ObjexxFCL::Optional<Real64 const> QCoilReq, // coil load to be met
+                                       ObjexxFCL::Optional<Real64> QCoilActual, // coil load actually delivered returned to calling component
+                                       ObjexxFCL::Optional_bool_const SuppHeat, // True if current heating coil is a supplemental heating coil
+                                       ObjexxFCL::Optional<HVAC::FanOp const> fanOpMode, // fan operating mode, FanOp::Cycling or FanOp::Continuous
+                                       ObjexxFCL::Optional<Real64 const> PartLoadRatio,  // part-load ratio of heating coil
+                                       ObjexxFCL::Optional_int StageNum,
+                                       ObjexxFCL::Optional<Real64 const> SpeedRatio // Speed ratio of MultiStage heating coil
+    )
+    {
+        // SUBROUTINE INFORMATION:
+        //       AUTHOR         Richard Liesen
+        //       DATE WRITTEN   May 2000
+
+        // PURPOSE OF THIS SUBROUTINE:
+        // This subroutine manages HeatingCoil component simulation.
+
+        Real64 QCoilActual2;  // coil load actually delivered returned from specific coil
+        HVAC::FanOp fanOp;    // fan operating mode
+        Real64 PartLoadFrac;  // part-load fraction of heating coil
+        Real64 QCoilRequired; // local variable for optional argument
+
+
         if (present(SuppHeat)) {
             state.dataHeatingCoils->CoilIsSuppHeater = SuppHeat;
         } else {
@@ -191,17 +229,17 @@ namespace HeatingCoils {
         }
 
         // With the correct CoilNum Initialize
-        InitHeatingCoil(state, CoilNum, FirstHVACIteration, QCoilRequired); // Initialize all HeatingCoil related parameters
+        InitHeatingCoil(state, coilNum, FirstHVACIteration, QCoilRequired); // Initialize all HeatingCoil related parameters
 
         // Calculate the Correct HeatingCoil Model with the current CoilNum
-        switch (state.dataHeatingCoils->HeatingCoil(CoilNum).HCoilType_Num) {
-        case HVAC::Coil_HeatingElectric: {
-            CalcElectricHeatingCoil(state, CoilNum, QCoilRequired, QCoilActual2, fanOp, PartLoadFrac);
+        switch (state.dataHeatingCoils->HeatingCoil(coilNum).coilType) {
+        case HVAC::CoilType::HeatingElectric: {
+            CalcElectricHeatingCoil(state, coilNum, QCoilRequired, QCoilActual2, fanOp, PartLoadFrac);
         } break;
-        case HVAC::Coil_HeatingElectric_MultiStage: {
+        case HVAC::CoilType::HeatingElectricMultiStage: {
             CalcMultiStageElectricHeatingCoil(
                 state,
-                CoilNum,
+                coilNum,
                 SpeedRatio,
                 PartLoadRatio,
                 StageNum,
@@ -209,19 +247,22 @@ namespace HeatingCoils {
                 QCoilActual2,
                 state.dataHeatingCoils->CoilIsSuppHeater); // Autodesk:OPTIONAL SpeedRatio, PartLoadRatio, StageNum used without PRESENT check
         } break;
-        case HVAC::Coil_HeatingGasOrOtherFuel: {
-            CalcFuelHeatingCoil(state, CoilNum, QCoilRequired, QCoilActual2, fanOp, PartLoadFrac);
+          
+        case HVAC::CoilType::HeatingGasOrOtherFuel: {
+            CalcFuelHeatingCoil(state, coilNum, QCoilRequired, QCoilActual2, fanOp, PartLoadFrac);
         } break;
-        case HVAC::Coil_HeatingGas_MultiStage: {
+
+        case HVAC::CoilType::HeatingGasMultiStage: {
             CalcMultiStageGasHeatingCoil(state,
-                                         CoilNum,
+                                         coilNum,
                                          SpeedRatio,
                                          PartLoadRatio,
                                          StageNum,
                                          fanOp); // Autodesk:OPTIONAL SpeedRatio, PartLoadRatio, StageNum used without PRESENT check
         } break;
-        case HVAC::Coil_HeatingDesuperheater: {
-            CalcDesuperheaterHeatingCoil(state, CoilNum, QCoilRequired, QCoilActual2);
+
+        case HVAC::CoilType::HeatingDesuperheater: {
+            CalcDesuperheaterHeatingCoil(state, coilNum, QCoilRequired, QCoilActual2);
         } break;
         default:
             QCoilActual2 = 0.0;
@@ -229,16 +270,16 @@ namespace HeatingCoils {
         }
 
         // Update the current HeatingCoil to the outlet nodes
-        UpdateHeatingCoil(state, CoilNum);
+        UpdateHeatingCoil(state, coilNum);
 
         // Report the current HeatingCoil
-        ReportHeatingCoil(state, CoilNum, state.dataHeatingCoils->CoilIsSuppHeater);
+        ReportHeatingCoil(state, coilNum, state.dataHeatingCoils->CoilIsSuppHeater);
 
         if (present(QCoilActual)) {
             QCoilActual = QCoilActual2;
         }
     }
-
+  
     void GetHeatingCoilInput(EnergyPlusData &state)
     {
 
@@ -268,8 +309,8 @@ namespace HeatingCoils {
         int NumNums;
         int IOStat;
         int StageNum;
-        bool DXCoilErrFlag; // Used in GetDXCoil mining functions
-        bool errFlag;
+
+        bool ErrorsFound = false;
 
         state.dataHeatingCoils->NumElecCoil = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Coil:Heating:Electric");
         state.dataHeatingCoils->NumElecCoilMultiStage =
@@ -289,33 +330,31 @@ namespace HeatingCoils {
             state.dataHeatingCoils->CheckEquipName.dimension(state.dataHeatingCoils->NumHeatingCoils, true);
         }
 
-        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-            state, "Coil:Heating:Electric", state.dataHeatingCoils->TotalArgs, NumAlphas, NumNums);
-        state.dataHeatingCoils->MaxNums = max(state.dataHeatingCoils->MaxNums, NumNums);
-        state.dataHeatingCoils->MaxAlphas = max(state.dataHeatingCoils->MaxAlphas, NumAlphas);
-        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-            state, "Coil:Heating:Electric:MultiStage", state.dataHeatingCoils->TotalArgs, NumAlphas, NumNums);
-        state.dataHeatingCoils->MaxNums = max(state.dataHeatingCoils->MaxNums, NumNums);
-        state.dataHeatingCoils->MaxAlphas = max(state.dataHeatingCoils->MaxAlphas, NumAlphas);
-        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-            state, "Coil:Heating:Fuel", state.dataHeatingCoils->TotalArgs, NumAlphas, NumNums);
-        state.dataHeatingCoils->MaxNums = max(state.dataHeatingCoils->MaxNums, NumNums);
-        state.dataHeatingCoils->MaxAlphas = max(state.dataHeatingCoils->MaxAlphas, NumAlphas);
-        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-            state, "Coil:Heating:Gas:MultiStage", state.dataHeatingCoils->TotalArgs, NumAlphas, NumNums);
-        state.dataHeatingCoils->MaxNums = max(state.dataHeatingCoils->MaxNums, NumNums);
-        state.dataHeatingCoils->MaxAlphas = max(state.dataHeatingCoils->MaxAlphas, NumAlphas);
-        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
-            state, "Coil:Heating:Desuperheater", state.dataHeatingCoils->TotalArgs, NumAlphas, NumNums);
-        state.dataHeatingCoils->MaxNums = max(state.dataHeatingCoils->MaxNums, NumNums);
-        state.dataHeatingCoils->MaxAlphas = max(state.dataHeatingCoils->MaxAlphas, NumAlphas);
-
-        Alphas.allocate(state.dataHeatingCoils->MaxAlphas);
-        cAlphaFields.allocate(state.dataHeatingCoils->MaxAlphas);
-        cNumericFields.allocate(state.dataHeatingCoils->MaxNums);
-        Numbers.dimension(state.dataHeatingCoils->MaxNums, 0.0);
-        lAlphaBlanks.dimension(state.dataHeatingCoils->MaxAlphas, true);
-        lNumericBlanks.dimension(state.dataHeatingCoils->MaxNums, true);
+        int MaxNums = 0;
+        int MaxAlphas = 0;
+        int TotalArgs = 0;
+        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "Coil:Heating:Electric", TotalArgs, NumAlphas, NumNums);
+        MaxNums = max(MaxNums, NumNums);
+        MaxAlphas = max(MaxAlphas, NumAlphas);
+        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "Coil:Heating:Electric:MultiStage", TotalArgs, NumAlphas, NumNums);
+        MaxNums = max(MaxNums, NumNums);
+        MaxAlphas = max(MaxAlphas, NumAlphas);
+        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "Coil:Heating:Fuel", TotalArgs, NumAlphas, NumNums);
+        MaxNums = max(MaxNums, NumNums);
+        MaxAlphas = max(MaxAlphas, NumAlphas);
+        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "Coil:Heating:Gas:MultiStage", TotalArgs, NumAlphas, NumNums);
+        MaxNums = max(MaxNums, NumNums);
+        MaxAlphas = max(MaxAlphas, NumAlphas);
+        state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "Coil:Heating:Desuperheater", TotalArgs, NumAlphas, NumNums);
+        MaxNums = max(MaxNums, NumNums);
+        MaxAlphas = max(MaxAlphas, NumAlphas);
+
+        Alphas.allocate(MaxAlphas);
+        cAlphaFields.allocate(MaxAlphas);
+        cNumericFields.allocate(MaxNums);
+        Numbers.dimension(MaxNums, 0.0);
+        lAlphaBlanks.dimension(MaxAlphas, true);
+        lNumericBlanks.dimension(MaxNums, true);
 
         // Get the data for electric heating coils
         for (int ElecCoilNum = 1; ElecCoilNum <= state.dataHeatingCoils->NumElecCoil; ++ElecCoilNum) {
@@ -340,64 +379,55 @@ namespace HeatingCoils {
                                                                      cNumericFields);
 
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-            heatingCoilNumericFields.FieldNames.allocate(state.dataHeatingCoils->MaxNums);
+            heatingCoilNumericFields.FieldNames.allocate(MaxNums);
             heatingCoilNumericFields.FieldNames = cNumericFields;
 
             // InputErrorsFound will be set to True if problem was found, left untouched otherwise
-            GlobalNames::VerifyUniqueCoilName(
-                state, CurrentModuleObject, Alphas(1), state.dataHeatingCoils->InputErrorsFound, CurrentModuleObject + " Name");
+            GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, Alphas(1), ErrorsFound, CurrentModuleObject + " Name");
 
             heatingCoil.Name = Alphas(1);
             if (lAlphaBlanks(2)) {
                 heatingCoil.availSched = Sched::GetScheduleAlwaysOn(state);
             } else if ((heatingCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ErrorsFound = true;
             }
 
-            heatingCoil.HeatingCoilType = "Heating";
             heatingCoil.HeatingCoilModel = "Electric";
-            heatingCoil.HCoilType_Num = HVAC::Coil_HeatingElectric;
+            heatingCoil.coilType = HVAC::CoilType::HeatingElectric;
 
             heatingCoil.Efficiency = Numbers(1);
             heatingCoil.NominalCapacity = Numbers(2);
-            errFlag = false;
             heatingCoil.AirInletNodeNum = GetOnlySingleNode(state,
                                                             Alphas(3),
-                                                            errFlag,
+                                                            ErrorsFound,
                                                             DataLoopNode::ConnectionObjectType::CoilHeatingElectric,
                                                             Alphas(1),
                                                             DataLoopNode::NodeFluidType::Air,
                                                             DataLoopNode::ConnectionType::Inlet,
                                                             NodeInputManager::CompFluidStream::Primary,
                                                             DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
-            errFlag = false;
             heatingCoil.AirOutletNodeNum = GetOnlySingleNode(state,
                                                              Alphas(4),
-                                                             errFlag,
+                                                             ErrorsFound,
                                                              DataLoopNode::ConnectionObjectType::CoilHeatingElectric,
                                                              Alphas(1),
                                                              DataLoopNode::NodeFluidType::Air,
                                                              DataLoopNode::ConnectionType::Outlet,
                                                              NodeInputManager::CompFluidStream::Primary,
                                                              DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
-            errFlag = false;
             heatingCoil.TempSetPointNodeNum = GetOnlySingleNode(state,
                                                                 Alphas(5),
-                                                                errFlag,
+                                                                ErrorsFound,
                                                                 DataLoopNode::ConnectionObjectType::CoilHeatingElectric,
                                                                 Alphas(1),
                                                                 DataLoopNode::NodeFluidType::Air,
                                                                 DataLoopNode::ConnectionType::Sensor,
                                                                 NodeInputManager::CompFluidStream::Primary,
                                                                 DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
-
             // Setup Report variables for the Electric Coils
             // CurrentModuleObject = "Coil:Heating:Electric"
             SetupOutputVariable(state,
@@ -460,23 +490,21 @@ namespace HeatingCoils {
                                                                      cNumericFields);
 
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-            heatingCoilNumericFields.FieldNames.allocate(state.dataHeatingCoils->MaxNums);
+            heatingCoilNumericFields.FieldNames.allocate(MaxNums);
             heatingCoilNumericFields.FieldNames = cNumericFields;
 
             // InputErrorsFound will be set to True if problem was found, left untouched otherwise
-            GlobalNames::VerifyUniqueCoilName(
-                state, CurrentModuleObject, Alphas(1), state.dataHeatingCoils->InputErrorsFound, CurrentModuleObject + " Name");
+            GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, Alphas(1), ErrorsFound, CurrentModuleObject + " Name");
             heatingCoil.Name = Alphas(1);
             if (lAlphaBlanks(2)) {
                 heatingCoil.availSched = Sched::GetScheduleAlwaysOn(state);
             } else if ((heatingCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ErrorsFound = true;
             }
 
-            heatingCoil.HeatingCoilType = "Heating";
             heatingCoil.HeatingCoilModel = "ElectricMultiStage";
-            heatingCoil.HCoilType_Num = HVAC::Coil_HeatingElectric_MultiStage;
+            heatingCoil.coilType = HVAC::CoilType::HeatingElectricMultiStage;
 
             heatingCoil.NumOfStages = static_cast<int>(Numbers(1));
 
@@ -488,44 +516,39 @@ namespace HeatingCoils {
                 heatingCoil.MSEfficiency(StageNum) = Numbers(StageNum * 2);
                 heatingCoil.MSNominalCapacity(StageNum) = Numbers(StageNum * 2 + 1);
             }
-
-            errFlag = false;
+            heatingCoil.NominalCapacity = heatingCoil.MSNominalCapacity(heatingCoil.NumOfStages);
+            
             heatingCoil.AirInletNodeNum = GetOnlySingleNode(state,
                                                             Alphas(3),
-                                                            errFlag,
+                                                            ErrorsFound,
                                                             DataLoopNode::ConnectionObjectType::CoilHeatingElectricMultiStage,
                                                             Alphas(1),
                                                             DataLoopNode::NodeFluidType::Air,
                                                             DataLoopNode::ConnectionType::Inlet,
                                                             NodeInputManager::CompFluidStream::Primary,
                                                             DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
-            errFlag = false;
+
             heatingCoil.AirOutletNodeNum = GetOnlySingleNode(state,
                                                              Alphas(4),
-                                                             errFlag,
+                                                             ErrorsFound,
                                                              DataLoopNode::ConnectionObjectType::CoilHeatingElectricMultiStage,
                                                              Alphas(1),
                                                              DataLoopNode::NodeFluidType::Air,
                                                              DataLoopNode::ConnectionType::Outlet,
                                                              NodeInputManager::CompFluidStream::Primary,
                                                              DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
-            errFlag = false;
             heatingCoil.TempSetPointNodeNum = GetOnlySingleNode(state,
                                                                 Alphas(5),
-                                                                errFlag,
+                                                                ErrorsFound,
                                                                 DataLoopNode::ConnectionObjectType::CoilHeatingElectricMultiStage,
                                                                 Alphas(1),
                                                                 DataLoopNode::NodeFluidType::Air,
                                                                 DataLoopNode::ConnectionType::Sensor,
                                                                 NodeInputManager::CompFluidStream::Primary,
                                                                 DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
-
             // Setup Report variables for the Electric Coils
             // CurrentModuleObject = "Coil:Heating:Electric:MultiStage"
             SetupOutputVariable(state,
@@ -587,23 +610,21 @@ namespace HeatingCoils {
                                                                      cNumericFields);
 
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-            heatingCoilNumericFields.FieldNames.allocate(state.dataHeatingCoils->MaxNums);
+            heatingCoilNumericFields.FieldNames.allocate(MaxNums);
             heatingCoilNumericFields.FieldNames = cNumericFields;
 
             // InputErrorsFound will be set to True if problem was found, left untouched otherwise
-            GlobalNames::VerifyUniqueCoilName(
-                state, CurrentModuleObject, Alphas(1), state.dataHeatingCoils->InputErrorsFound, CurrentModuleObject + " Name");
+            GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, Alphas(1), ErrorsFound, CurrentModuleObject + " Name");
             heatingCoil.Name = Alphas(1);
             if (lAlphaBlanks(2)) {
                 heatingCoil.availSched = Sched::GetScheduleAlwaysOn(state);
             } else if ((heatingCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ErrorsFound = true;
             }
 
-            heatingCoil.HeatingCoilType = "Heating";
             heatingCoil.HeatingCoilModel = "Fuel";
-            heatingCoil.HCoilType_Num = HVAC::Coil_HeatingGasOrOtherFuel;
+            heatingCoil.coilType = HVAC::CoilType::HeatingGasOrOtherFuel;
 
             heatingCoil.FuelType = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, Alphas(3)));
             if (!(heatingCoil.FuelType == Constant::eFuel::NaturalGas || heatingCoil.FuelType == Constant::eFuel::Propane ||
@@ -611,56 +632,43 @@ namespace HeatingCoils {
                   heatingCoil.FuelType == Constant::eFuel::FuelOilNo1 || heatingCoil.FuelType == Constant::eFuel::FuelOilNo2 ||
                   heatingCoil.FuelType == Constant::eFuel::OtherFuel1 || heatingCoil.FuelType == Constant::eFuel::OtherFuel2 ||
                   heatingCoil.FuelType == Constant::eFuel::Coal)) {
-                ShowSevereError(state,
-                                format("{}{}: Invalid {} entered ={} for {}={}",
-                                       RoutineName,
-                                       CurrentModuleObject,
-                                       cAlphaFields(3),
-                                       Alphas(3),
-                                       cAlphaFields(1),
-                                       Alphas(1)));
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(3), Alphas(3));
+                ErrorsFound = true;
             }
-            std::string const sFuelType(Constant::eFuelNames[static_cast<int>(heatingCoil.FuelType)]);
-
+            
             heatingCoil.Efficiency = Numbers(1);
             heatingCoil.NominalCapacity = Numbers(2);
-            errFlag = false;
             heatingCoil.AirInletNodeNum = GetOnlySingleNode(state,
                                                             Alphas(4),
-                                                            errFlag,
+                                                            ErrorsFound, 
                                                             DataLoopNode::ConnectionObjectType::CoilHeatingFuel,
                                                             Alphas(1),
                                                             DataLoopNode::NodeFluidType::Air,
                                                             DataLoopNode::ConnectionType::Inlet,
                                                             NodeInputManager::CompFluidStream::Primary,
                                                             DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
-            errFlag = false;
+
             heatingCoil.AirOutletNodeNum = GetOnlySingleNode(state,
                                                              Alphas(5),
-                                                             errFlag,
+                                                             ErrorsFound,
                                                              DataLoopNode::ConnectionObjectType::CoilHeatingFuel,
                                                              Alphas(1),
                                                              DataLoopNode::NodeFluidType::Air,
                                                              DataLoopNode::ConnectionType::Outlet,
                                                              NodeInputManager::CompFluidStream::Primary,
                                                              DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(4), Alphas(5), "Air Nodes");
 
-            errFlag = false;
             heatingCoil.TempSetPointNodeNum = GetOnlySingleNode(state,
                                                                 Alphas(6),
-                                                                errFlag,
+                                                                ErrorsFound,
                                                                 DataLoopNode::ConnectionObjectType::CoilHeatingFuel,
                                                                 Alphas(1),
                                                                 DataLoopNode::NodeFluidType::Air,
                                                                 DataLoopNode::ConnectionType::Sensor,
                                                                 NodeInputManager::CompFluidStream::Primary,
                                                                 DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             // parasitic electric load associated with the fuel heating coil
             heatingCoil.ParasiticElecLoad = Numbers(3);
@@ -691,7 +699,7 @@ namespace HeatingCoils {
                                 OutputProcessor::StoreType::Average,
                                 heatingCoil.Name);
             SetupOutputVariable(state,
-                                format("Heating Coil {} Energy", sFuelType),
+                                format("Heating Coil {} Energy", Constant::eFuelNames[(int)heatingCoil.FuelType]),
                                 Constant::Units::J,
                                 heatingCoil.FuelUseLoad,
                                 OutputProcessor::TimeStepType::System,
@@ -701,7 +709,7 @@ namespace HeatingCoils {
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::Heating);
             SetupOutputVariable(state,
-                                format("Heating Coil {} Rate", sFuelType),
+                                format("Heating Coil {} Rate", Constant::eFuelNames[(int)heatingCoil.FuelType]),
                                 Constant::Units::W,
                                 heatingCoil.FuelUseRate,
                                 OutputProcessor::TimeStepType::System,
@@ -732,14 +740,14 @@ namespace HeatingCoils {
                                 OutputProcessor::StoreType::Average,
                                 heatingCoil.Name);
             SetupOutputVariable(state,
-                                "Heating Coil Ancillary " + sFuelType + " Rate",
+                                format("Heating Coil Ancillary {} Rate", Constant::eFuelNames[(int)heatingCoil.FuelType]),
                                 Constant::Units::W,
                                 heatingCoil.ParasiticFuelRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
                                 heatingCoil.Name);
             SetupOutputVariable(state,
-                                "Heating Coil Ancillary " + sFuelType + " Energy",
+                                format("Heating Coil Ancillary {} Energy", Constant::eFuelNames[(int)heatingCoil.FuelType]),
                                 Constant::Units::J,
                                 heatingCoil.ParasiticFuelConsumption,
                                 OutputProcessor::TimeStepType::System,
@@ -775,24 +783,22 @@ namespace HeatingCoils {
 
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
 
-            heatingCoilNumericFields.FieldNames.allocate(state.dataHeatingCoils->MaxNums);
+            heatingCoilNumericFields.FieldNames.allocate(MaxNums);
             heatingCoilNumericFields.FieldNames = cNumericFields;
 
             // InputErrorsFound will be set to True if problem was found, left untouched otherwise
-            GlobalNames::VerifyUniqueCoilName(
-                state, CurrentModuleObject, Alphas(1), state.dataHeatingCoils->InputErrorsFound, CurrentModuleObject + " Name");
+            GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, Alphas(1), ErrorsFound, CurrentModuleObject + " Name");
             heatingCoil.Name = Alphas(1);
 
             if (lAlphaBlanks(2)) {
                 heatingCoil.availSched = Sched::GetScheduleAlwaysOn(state);
             } else if ((heatingCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ErrorsFound = true;
             }
 
-            heatingCoil.HeatingCoilType = "Heating";
             heatingCoil.HeatingCoilModel = "GasMultiStage";
-            heatingCoil.HCoilType_Num = HVAC::Coil_HeatingGas_MultiStage;
+            heatingCoil.coilType = HVAC::CoilType::HeatingGasMultiStage;
 
             heatingCoil.ParasiticFuelCapacity = Numbers(1);
 
@@ -809,42 +815,37 @@ namespace HeatingCoils {
                 heatingCoil.MSParasiticElecLoad(StageNum) = Numbers(StageNum * 3 + 2);
             }
 
-            errFlag = false;
             heatingCoil.AirInletNodeNum = GetOnlySingleNode(state,
                                                             Alphas(3),
-                                                            errFlag,
+                                                            ErrorsFound,
                                                             DataLoopNode::ConnectionObjectType::CoilHeatingGasMultiStage,
                                                             Alphas(1),
                                                             DataLoopNode::NodeFluidType::Air,
                                                             DataLoopNode::ConnectionType::Inlet,
                                                             NodeInputManager::CompFluidStream::Primary,
                                                             DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
-            errFlag = false;
+
             heatingCoil.AirOutletNodeNum = GetOnlySingleNode(state,
                                                              Alphas(4),
-                                                             errFlag,
+                                                             ErrorsFound, 
                                                              DataLoopNode::ConnectionObjectType::CoilHeatingGasMultiStage,
                                                              Alphas(1),
                                                              DataLoopNode::NodeFluidType::Air,
                                                              DataLoopNode::ConnectionType::Outlet,
                                                              NodeInputManager::CompFluidStream::Primary,
                                                              DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
-            errFlag = false;
             heatingCoil.TempSetPointNodeNum = GetOnlySingleNode(state,
                                                                 Alphas(5),
-                                                                errFlag,
+                                                                ErrorsFound, 
                                                                 DataLoopNode::ConnectionObjectType::CoilHeatingGasMultiStage,
                                                                 Alphas(1),
                                                                 DataLoopNode::NodeFluidType::Air,
                                                                 DataLoopNode::ConnectionType::Sensor,
                                                                 NodeInputManager::CompFluidStream::Primary,
                                                                 DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             // parasitic electric load associated with the gas heating coil
             heatingCoil.ParasiticElecLoad = Numbers(10);
@@ -956,53 +957,48 @@ namespace HeatingCoils {
                                                                      cNumericFields);
 
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-            heatingCoilNumericFields.FieldNames.allocate(state.dataHeatingCoils->MaxNums);
+            heatingCoilNumericFields.FieldNames.allocate(MaxNums);
             heatingCoilNumericFields.FieldNames = cNumericFields;
 
             // InputErrorsFound will be set to True if problem was found, left untouched otherwise
-            GlobalNames::VerifyUniqueCoilName(
-                state, CurrentModuleObject, Alphas(1), state.dataHeatingCoils->InputErrorsFound, CurrentModuleObject + " Name");
+            GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, Alphas(1), ErrorsFound, CurrentModuleObject + " Name");
             heatingCoil.Name = Alphas(1);
             if (lAlphaBlanks(2)) {
                 heatingCoil.availSched = Sched::GetScheduleAlwaysOn(state);
             } else if ((heatingCoil.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ErrorsFound = true;
             } else if (!heatingCoil.availSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
                 Sched::ShowSevereBadMinMax(state, eoh, cAlphaFields(2), Alphas(2), Clusive::In, 0.0, Clusive::In, 1.0);
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ErrorsFound = true;
             }
 
-            heatingCoil.HeatingCoilType = "Heating";
             heatingCoil.HeatingCoilModel = "Desuperheater";
-            heatingCoil.HCoilType_Num = HVAC::Coil_HeatingDesuperheater;
+            heatingCoil.coilType = HVAC::CoilType::HeatingDesuperheater;
 
             // HeatingCoil(CoilNum)%Efficiency       = Numbers(1)
             //(Numbers(1)) error limits checked and defaults applied on efficiency after
             //       identifying souce type.
 
-            errFlag = false;
             heatingCoil.AirInletNodeNum = GetOnlySingleNode(state,
                                                             Alphas(3),
-                                                            errFlag,
+                                                            ErrorsFound,
                                                             DataLoopNode::ConnectionObjectType::CoilHeatingDesuperheater,
                                                             Alphas(1),
                                                             DataLoopNode::NodeFluidType::Air,
                                                             DataLoopNode::ConnectionType::Inlet,
                                                             NodeInputManager::CompFluidStream::Primary,
                                                             DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
-            errFlag = false;
+
             heatingCoil.AirOutletNodeNum = GetOnlySingleNode(state,
                                                              Alphas(4),
-                                                             errFlag,
+                                                             ErrorsFound,
                                                              DataLoopNode::ConnectionObjectType::CoilHeatingDesuperheater,
                                                              Alphas(1),
                                                              DataLoopNode::NodeFluidType::Air,
                                                              DataLoopNode::ConnectionType::Outlet,
                                                              NodeInputManager::CompFluidStream::Primary,
                                                              DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, Alphas(1), Alphas(3), Alphas(4), "Air Nodes");
 
@@ -1017,7 +1013,7 @@ namespace HeatingCoils {
                         ShowSevereError(
                             state,
                             format("{}, \"{}\" heat reclaim recovery efficiency must be >= 0 and <=0.9", CurrentModuleObject, heatingCoil.Name));
-                        state.dataHeatingCoils->InputErrorsFound = true;
+                        ErrorsFound = true;
                     }
                 }
             } else {
@@ -1029,7 +1025,7 @@ namespace HeatingCoils {
                         ShowSevereError(
                             state,
                             format("{}, \"{}\" heat reclaim recovery efficiency must be >= 0 and <=0.3", CurrentModuleObject, heatingCoil.Name));
-                        state.dataHeatingCoils->InputErrorsFound = true;
+                        ErrorsFound = true;
                     }
                 }
             }
@@ -1037,209 +1033,154 @@ namespace HeatingCoils {
             // Find the DX equipment index associated with the desuperheater heating coil.
             // The CoilNum may not be found here when zone heating equip. exists. Check again in InitHeatingCoil.
             // (when zone equipment heating coils are included in the input, the air loop DX equipment has not yet been read in)
-            if (Util::SameString(Alphas(5), "Refrigeration:CompressorRack")) {
-                heatingCoil.ReclaimHeatingSource = HeatObjTypes::COMPRESSORRACK_REFRIGERATEDCASE;
-                RefrigeratedCase::GetRefrigeratedRackIndex(
-                    state, Alphas(6), heatingCoil.ReclaimHeatingSourceIndexNum, DataHeatBalance::RefrigSystemType::Rack, DXCoilErrFlag, Alphas(5));
-                if (heatingCoil.ReclaimHeatingSourceIndexNum > 0) {
-                    if (allocated(state.dataHeatBal->HeatReclaimRefrigeratedRack)) {
-                        DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                            state.dataHeatBal->HeatReclaimRefrigeratedRack(heatingCoil.ReclaimHeatingSourceIndexNum);
-                        if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
-                            HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
-                            std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
-                        }
-                        HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
-                        if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                            ShowSevereError(
-                                state,
-                                format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.3",
-                                       HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                       heatingCoil.Name,
-                                       heatingCoil.ReclaimHeatingCoilName));
-                        }
-                        state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
+            heatingCoil.ReclaimHeatSourceName = Alphas(6);
+            heatingCoil.ReclaimHeatSourceType = static_cast<HVAC::HeatReclaimType>(getEnumValue(HVAC::heatReclaimTypeNamesUC, Alphas(5)));
+            if (heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::Invalid) {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(5), Alphas(5));
+                ShowContinueError(state, "Valid desuperheater heat source objects are:");
+                ShowContinueError(state,
+                                  "Refrigeration:CompressorRack, Coil:Cooling:DX:SingleSpeed, Refrigeration:Condenser:AirCooled, "
+                                  "Refrigeration:Condenser:EvaporativeCooled, Refrigeration:Condenser:WaterCooled,Coil:Cooling:DX:TwoSpeed, and "
+                                  "Coil:Cooling:DX:TwoStageWithHumidityControlMode");
+                ErrorsFound = true;
+
+            } else if (heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCompressorRack) {
+                heatingCoil.ReclaimHeatSourceNum = RefrigeratedCase::GetRefrigeratedRackIndex(state, heatingCoil.ReclaimHeatSourceName);
+                if (heatingCoil.ReclaimHeatSourceNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(6), heatingCoil.ReclaimHeatSourceName);
+                    ErrorsFound = true;
+                } else if (allocated(state.dataHeatBal->HeatReclaimRefrigeratedRack)) {
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimRefrigeratedRack(heatingCoil.ReclaimHeatSourceNum);
+                    if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
+                        HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
+                        std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
                     }
-                }
-            } else if ((Util::SameString(Alphas(5), "Refrigeration:Condenser:AirCooled")) ||
-                       (Util::SameString(Alphas(5), "Refrigeration:Condenser:EvaporativeCooled")) ||
-                       (Util::SameString(Alphas(5), "Refrigeration:Condenser:WaterCooled"))) {
-                heatingCoil.ReclaimHeatingSource = HeatObjTypes::CONDENSER_REFRIGERATION;
-                RefrigeratedCase::GetRefrigeratedRackIndex(state,
-                                                           Alphas(6),
-                                                           heatingCoil.ReclaimHeatingSourceIndexNum,
-                                                           DataHeatBalance::RefrigSystemType::Detailed,
-                                                           DXCoilErrFlag,
-                                                           Alphas(5));
-                if (heatingCoil.ReclaimHeatingSourceIndexNum > 0) {
-                    if (allocated(state.dataHeatBal->HeatReclaimRefrigCondenser)) {
-                        DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                            state.dataHeatBal->HeatReclaimRefrigCondenser(heatingCoil.ReclaimHeatingSourceIndexNum);
-                        if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
-                            HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
-                            std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
-                        }
-                        HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
-                        if (HeatReclaim.ReclaimEfficiencyTotal > 0.9) {
-                            ShowSevereError(
-                                state,
-                                format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.9",
-                                       HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                       heatingCoil.Name,
-                                       heatingCoil.ReclaimHeatingCoilName));
-                        }
-                        state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
+                    HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
+                    if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
+                        ShowSevereError(
+                            state,
+                            format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.3",
+                                   HVAC::coilTypeNames[(int)heatingCoil.coilType],
+                                   heatingCoil.Name,
+                                   heatingCoil.ReclaimHeatSourceName));
                     }
+                    state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
                 }
-            } else if (Util::SameString(Alphas(5), "Coil:Cooling:DX:SingleSpeed")) {
-                heatingCoil.ReclaimHeatingSource = HeatObjTypes::COIL_DX_COOLING;
-                DXCoils::GetDXCoilIndex(state, Alphas(6), heatingCoil.ReclaimHeatingSourceIndexNum, DXCoilErrFlag, Alphas(5));
-                if (heatingCoil.ReclaimHeatingSourceIndexNum > 0) {
-                    if (allocated(state.dataHeatBal->HeatReclaimDXCoil)) {
-                        DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                            state.dataHeatBal->HeatReclaimDXCoil(heatingCoil.ReclaimHeatingSourceIndexNum);
-                        if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
-                            HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
-                            std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
-                        }
-                        HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
-                        if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                            ShowSevereError(
-                                state,
-                                format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.3",
-                                       HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                       heatingCoil.Name,
-                                       heatingCoil.ReclaimHeatingCoilName));
-                        }
-                        state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
+                
+            } else if (heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled || 
+                       heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled || 
+                       heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled) { 
+                heatingCoil.ReclaimHeatSourceNum = RefrigeratedCase::GetRefrigeratedCondenserIndex(state, heatingCoil.ReclaimHeatSourceName);
+                if (heatingCoil.ReclaimHeatSourceNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(6), heatingCoil.ReclaimHeatSourceName);
+                    ErrorsFound = true;
+                } else if (allocated(state.dataHeatBal->HeatReclaimRefrigCondenser)) {
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimRefrigCondenser(heatingCoil.ReclaimHeatSourceNum);
+                    if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
+                        HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
+                        std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
                     }
-                }
-                if (heatingCoil.ReclaimHeatingSourceIndexNum > 0) state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
-            } else if (Util::SameString(Alphas(5), "Coil:Cooling:DX:VariableSpeed")) {
-                heatingCoil.ReclaimHeatingSource = HeatObjTypes::COIL_DX_VARIABLE_COOLING;
-                heatingCoil.ReclaimHeatingSourceIndexNum = VariableSpeedCoils::GetCoilIndexVariableSpeed(state, Alphas(5), Alphas(6), DXCoilErrFlag);
-                if (heatingCoil.ReclaimHeatingSourceIndexNum > 0) {
-                    if (allocated(state.dataHeatBal->HeatReclaimVS_Coil)) {
-                        DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                            state.dataHeatBal->HeatReclaimVS_Coil(heatingCoil.ReclaimHeatingSourceIndexNum);
-                        if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
-                            HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
-                            std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
-                        }
-                        HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
-                        if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                            ShowSevereError(
-                                state,
-                                format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.3",
-                                       HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                       heatingCoil.Name,
-                                       heatingCoil.ReclaimHeatingCoilName));
-                        }
-                        state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
+                    HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
+                    if (HeatReclaim.ReclaimEfficiencyTotal > 0.9) {
+                        ShowSevereError(
+                            state,
+                            format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.9",
+                                   HVAC::coilTypeNames[(int)heatingCoil.coilType],
+                                   heatingCoil.Name,
+                                   heatingCoil.ReclaimHeatSourceName));
                     }
+                    state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
                 }
-            } else if (Util::SameString(Alphas(5), "Coil:Cooling:DX:TwoSpeed")) {
-                heatingCoil.ReclaimHeatingSource = HeatObjTypes::COIL_DX_MULTISPEED;
-                DXCoils::GetDXCoilIndex(state, Alphas(6), heatingCoil.ReclaimHeatingSourceIndexNum, DXCoilErrFlag, Alphas(5));
-                if (heatingCoil.ReclaimHeatingSourceIndexNum > 0) {
-                    if (allocated(state.dataHeatBal->HeatReclaimDXCoil)) {
-                        DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                            state.dataHeatBal->HeatReclaimDXCoil(heatingCoil.ReclaimHeatingSourceIndexNum);
-                        if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
-                            HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
-                            std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
-                        }
-                        HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
-                        if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                            ShowSevereError(
-                                state,
-                                format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.3",
-                                       HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                       heatingCoil.Name,
-                                       heatingCoil.ReclaimHeatingCoilName));
-                        }
-                        state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
+                
+            } else if (heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::CoilCoolDXSingleSpeed ||
+                       heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiSpeed || 
+                       heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiMode) {
+                heatingCoil.ReclaimHeatSourceNum = DXCoils::GetCoilIndex(state, Alphas(6));
+                if (heatingCoil.ReclaimHeatSourceNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(6), heatingCoil.ReclaimHeatSourceName);
+                    ErrorsFound = true;
+                } else if (allocated(state.dataHeatBal->HeatReclaimDXCoil)) {
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimDXCoil(heatingCoil.ReclaimHeatSourceNum);
+                    if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
+                        HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
+                        std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
                     }
-                }
-            } else if (Util::SameString(Alphas(5), "Coil:Cooling:DX:TwoStageWithHumidityControlMode")) {
-                heatingCoil.ReclaimHeatingSource = HeatObjTypes::COIL_DX_MULTIMODE;
-                DXCoils::GetDXCoilIndex(state, Alphas(6), heatingCoil.ReclaimHeatingSourceIndexNum, DXCoilErrFlag, Alphas(5));
-                if (heatingCoil.ReclaimHeatingSourceIndexNum > 0) {
-                    if (allocated(state.dataHeatBal->HeatReclaimDXCoil)) {
-                        DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                            state.dataHeatBal->HeatReclaimDXCoil(heatingCoil.ReclaimHeatingSourceIndexNum);
-                        if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
-                            HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
-                            std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
-                        }
-                        HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
-                        if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                            ShowSevereError(
-                                state,
-                                format(R"({}, "{}" sum of heat reclaim recovery efficiencies from the same source coil: "{} " cannot be over 0.3)",
-                                       HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                       heatingCoil.Name,
-                                       heatingCoil.ReclaimHeatingCoilName));
-                        }
-                        state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
+                    HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
+                    if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
+                        ShowSevereError(
+                            state,
+                            format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.3",
+                                   HVAC::coilTypeNames[(int)heatingCoil.coilType],
+                                   heatingCoil.Name,
+                                   heatingCoil.ReclaimHeatSourceName));
                     }
+                    state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
                 }
-            } else if (Util::SameString(Alphas(5), "Coil:Cooling:DX")) {
-                heatingCoil.ReclaimHeatingSource = HeatObjTypes::COIL_COOLING_DX_NEW;
-                heatingCoil.ReclaimHeatingSourceIndexNum = CoilCoolingDX::factory(state, Alphas(6));
-                if (heatingCoil.ReclaimHeatingSourceIndexNum < 0) {
-                    ShowSevereError(
-                        state, format("{}={}, could not find desuperheater coil {}={}", CurrentModuleObject, heatingCoil.Name, Alphas(5), Alphas(6)));
-                    state.dataHeatingCoils->InputErrorsFound = true;
-                }
-                DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                    state.dataCoilCoolingDX->coilCoolingDXs[heatingCoil.ReclaimHeatingSourceIndexNum].reclaimHeat;
-                if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
-                    HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
-                    std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
+                if (heatingCoil.ReclaimHeatSourceNum > 0) state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
+                
+            } else if (heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::CoilCoolDXVariableSpeed) { 
+                heatingCoil.ReclaimHeatSourceNum = VariableSpeedCoils::GetCoilIndex(state, heatingCoil.ReclaimHeatSourceName);
+                if (heatingCoil.ReclaimHeatSourceNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(6), heatingCoil.ReclaimHeatSourceName);
+                    ErrorsFound = true;
+                } else if (allocated(state.dataHeatBal->HeatReclaimVS_Coil)) {
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimVS_Coil(heatingCoil.ReclaimHeatSourceNum);
+                    if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
+                        HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
+                        std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
+                    }
+                    HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
+                    if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
+                        ShowSevereError(
+                            state,
+                            format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{} \" cannot be over 0.3",
+                                   HVAC::coilTypeNames[(int)heatingCoil.coilType],
+                                   heatingCoil.Name,
+                                   heatingCoil.ReclaimHeatSourceName));
+                    }
+                    state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
                 }
-                HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
-                if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                    ShowSevereError(
-                        state,
-                        format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
-                               HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                               heatingCoil.Name,
-                               heatingCoil.ReclaimHeatingCoilName));
+                
+            } else if (heatingCoil.ReclaimHeatSourceType == HVAC::HeatReclaimType::CoilCoolDX) {
+                heatingCoil.ReclaimHeatSourceNum = CoilCoolingDX::factory(state, heatingCoil.ReclaimHeatSourceName);
+                if (heatingCoil.ReclaimHeatSourceNum < 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(6), heatingCoil.ReclaimHeatSourceName);
+                    ErrorsFound = true;
+                } else {
+                   auto &HeatReclaim = state.dataCoilCoolingDX->coilCoolingDXs[heatingCoil.ReclaimHeatSourceNum].reclaimHeat;
+                   if (!allocated(HeatReclaim.HVACDesuperheaterReclaimedHeat)) {
+                       HeatReclaim.HVACDesuperheaterReclaimedHeat.allocate(state.dataHeatingCoils->NumDesuperheaterCoil);
+                       std::fill(HeatReclaim.HVACDesuperheaterReclaimedHeat.begin(), HeatReclaim.HVACDesuperheaterReclaimedHeat.end(), 0.0);
+                   }
+                   HeatReclaim.ReclaimEfficiencyTotal += heatingCoil.Efficiency;
+                   if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
+                       ShowSevereError(
+                           state,
+                           format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
+                                  HVAC::coilTypeNames[(int)heatingCoil.coilType],
+                                  heatingCoil.Name,
+                                  heatingCoil.ReclaimHeatSourceName));
+                   }
+                   state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
                 }
-                state.dataHeatingCoils->ValidSourceType(CoilNum) = true;
-            } else {
-                ShowSevereError(
-                    state,
-                    format("{}, \"{}\" valid desuperheater heat source object type not found: {}", CurrentModuleObject, heatingCoil.Name, Alphas(5)));
-                ShowContinueError(state, "Valid desuperheater heat source objects are:");
-                ShowContinueError(state,
-                                  "Refrigeration:CompressorRack, Coil:Cooling:DX:SingleSpeed, Refrigeration:Condenser:AirCooled, "
-                                  "Refrigeration:Condenser:EvaporativeCooled, Refrigeration:Condenser:WaterCooled,Coil:Cooling:DX:TwoSpeed, and "
-                                  "Coil:Cooling:DX:TwoStageWithHumidityControlMode");
-                state.dataHeatingCoils->InputErrorsFound = true;
             }
 
-            heatingCoil.ReclaimHeatingCoilName = Alphas(6);
-
-            errFlag = false;
             heatingCoil.TempSetPointNodeNum = GetOnlySingleNode(state,
                                                                 Alphas(7),
-                                                                errFlag,
+                                                                ErrorsFound, 
                                                                 DataLoopNode::ConnectionObjectType::CoilHeatingDesuperheater,
                                                                 Alphas(1),
                                                                 DataLoopNode::NodeFluidType::Air,
                                                                 DataLoopNode::ConnectionType::Sensor,
                                                                 NodeInputManager::CompFluidStream::Primary,
                                                                 DataLoopNode::ObjectIsNotParent);
-            state.dataHeatingCoils->InputErrorsFound = errFlag || state.dataHeatingCoils->InputErrorsFound;
 
             // parasitic electric load associated with the desuperheater heating coil
             heatingCoil.ParasiticElecLoad = Numbers(2);
 
             if (Numbers(2) < 0.0) {
                 ShowSevereError(state, format("{}, \"{}\" parasitic electric load must be >= 0", CurrentModuleObject, heatingCoil.Name));
-                state.dataHeatingCoils->InputErrorsFound = true;
+                ErrorsFound = true;
             }
 
             // Setup Report variables for the Desuperheater Heating Coils
@@ -1287,7 +1228,7 @@ namespace HeatingCoils {
                                 heatingCoil.Name);
         }
 
-        if (state.dataHeatingCoils->InputErrorsFound) {
+        if (ErrorsFound) {
             ShowFatalError(state, format("{}Errors found in input.  Program terminates.", RoutineName));
         }
 
@@ -1364,7 +1305,7 @@ namespace HeatingCoils {
         }
 
         if (QCoilRequired == DataLoopNode::SensedLoadFlagValue && state.dataHeatingCoils->MySPTestFlag(CoilNum) &&
-            heatingCoil.HCoilType_Num != HVAC::Coil_HeatingElectric_MultiStage && heatingCoil.HCoilType_Num != HVAC::Coil_HeatingGas_MultiStage) {
+            heatingCoil.coilType != HVAC::CoilType::HeatingElectricMultiStage && heatingCoil.coilType != HVAC::CoilType::HeatingGasMultiStage) {
 
             //   If the coil is temperature controlled (QCoilReq == -999.0), both a control node and setpoint are required.
             if (!state.dataGlobal->SysSizingCalc && state.dataHVACGlobal->DoSetPointTest) {
@@ -1374,7 +1315,7 @@ namespace HeatingCoils {
                 //     3) TempSetPointNodeNum .GT. 0 and TempSetPoint == SensedNodeFlagValue, this is not correct, missing temperature setpoint
                 //     test 2) here (fatal message)
                 if (ControlNodeNum == 0) {
-                    ShowSevereError(state, format("{} \"{}\"", HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num), heatingCoil.Name));
+                    ShowSevereError(state, format("{} \"{}\"", HVAC::coilTypeNames[(int)heatingCoil.coilType], heatingCoil.Name));
                     ShowContinueError(state, "... Missing control node for heating coil.");
                     ShowContinueError(state, "... enter a control node name in the coil temperature setpoint node field for this heating coil.");
                     ShowContinueError(state, "... use a Setpoint Manager to establish a setpoint at the coil temperature setpoint node.");
@@ -1384,7 +1325,7 @@ namespace HeatingCoils {
                     auto const &controlNode = state.dataLoopNodes->Node(ControlNodeNum);
                     if (controlNode.TempSetPoint == DataLoopNode::SensedNodeFlagValue) {
                         if (!state.dataGlobal->AnyEnergyManagementSystemInModel) {
-                            ShowSevereError(state, format("{} \"{}\"", HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num), heatingCoil.Name));
+                            ShowSevereError(state, format("{} \"{}\"", HVAC::coilTypeNames[(int)heatingCoil.coilType], heatingCoil.Name));
                             ShowContinueError(state, "... Missing temperature setpoint for heating coil.");
                             ShowContinueError(state, "... use a Setpoint Manager to establish a setpoint at the coil temperature setpoint node.");
                             state.dataHeatingCoils->HeatingCoilFatalError = true;
@@ -1392,7 +1333,7 @@ namespace HeatingCoils {
                             EMSManager::CheckIfNodeSetPointManagedByEMS(
                                 state, ControlNodeNum, HVAC::CtrlVarType::Temp, state.dataHeatingCoils->HeatingCoilFatalError);
                             if (state.dataHeatingCoils->HeatingCoilFatalError) {
-                                ShowSevereError(state, format("{} \"{}\"", HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num), heatingCoil.Name));
+                                ShowSevereError(state, format("{} \"{}\"", HVAC::coilTypeNames[(int)heatingCoil.coilType], heatingCoil.Name));
                                 ShowContinueError(state, "... Missing temperature setpoint for heating coil.");
                                 ShowContinueError(state, "... use a Setpoint Manager to establish a setpoint at the coil temperature setpoint node.");
                                 ShowContinueError(state, "... or use an EMS Actuator to establish a setpoint at the coil temperature setpoint node.");
@@ -1412,7 +1353,7 @@ namespace HeatingCoils {
             //   4) TempSetPointNodeNum .GT. 0 and TempSetPoint /= SensedNodeFlagValue, control node not required if load based control
             //   test 3) and 4) here (warning only)
             if (ControlNodeNum > 0) {
-                ShowWarningError(state, format("{} \"{}\"", HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num), heatingCoil.Name));
+              ShowWarningError(state, format("{} \"{}\"", HVAC::coilTypeNames[(int)heatingCoil.coilType], heatingCoil.Name));
                 ShowContinueError(state, " The \"Temperature Setpoint Node Name\" input is not required for this heating coil.");
                 ShowContinueError(state, " Leaving the input field \"Temperature Setpoint Node Name\" blank will eliminate this warning.");
             }
@@ -1424,14 +1365,18 @@ namespace HeatingCoils {
             ShowFatalError(state, "... errors found in heating coil input.");
         }
 
+#ifdef GET_OUT
+        // Have we not done this already in GetInput?
+        
         // Find the heating source index for the desuperheater heating coil if not already found. This occurs when zone heating
         // equip. exists. (when zone equipment heating coils are included in the input, the air loop DX equipment has not yet been read)
         // Issue a single warning if the coil is not found and continue the simulation
-        if (!state.dataHeatingCoils->ValidSourceType(CoilNum) && (heatingCoil.HCoilType_Num == HVAC::Coil_HeatingDesuperheater) &&
+        if (!state.dataHeatingCoils->ValidSourceType(CoilNum) && (heatingCoil.coilType == HVAC::CoilType::HeatingDesuperheater) &&
             state.dataHeatingCoils->ShowSingleWarning(CoilNum)) {
             ++state.dataHeatingCoils->ValidSourceTypeCounter;
-            switch (heatingCoil.ReclaimHeatingSource) {
-            case HeatObjTypes::COMPRESSORRACK_REFRIGERATEDCASE: {
+            switch (heatingCoil.ReclaimHeatSourceType) {
+
+            case HeatReclaimType::RefrigeratedCaseRack: {
                 for (int RackNum = 1; RackNum <= state.dataRefrigCase->NumRefrigeratedRacks; ++RackNum) {
                     if (!Util::SameString(state.dataHeatBal->HeatReclaimRefrigeratedRack(RackNum).Name, heatingCoil.ReclaimHeatingCoilName)) continue;
                     heatingCoil.ReclaimHeatingSourceIndexNum = RackNum;
@@ -1446,7 +1391,7 @@ namespace HeatingCoils {
                                 ShowSevereError(
                                     state,
                                     format(R"({}, "{}" sum of heat reclaim recovery efficiencies from the same source coil: "{}" cannot be over 0.3)",
-                                           HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
+                                           HVAC::coilTypeNames[(int)heatingCoil.coilType],
                                            heatingCoil.Name,
                                            heatingCoil.ReclaimHeatingCoilName));
                             }
@@ -1471,7 +1416,7 @@ namespace HeatingCoils {
                                 ShowSevereError(
                                     state,
                                     format(R"({}, "{}" sum of heat reclaim recovery efficiencies from the same source coil: "{}" cannot be over 0.9)",
-                                           HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
+                                           HVAC::coilTypeNames[(int)heatingCoil.coilType],
                                            heatingCoil.Name,
                                            heatingCoil.ReclaimHeatingCoilName));
                             }
@@ -1498,7 +1443,7 @@ namespace HeatingCoils {
                                 ShowSevereError(
                                     state,
                                     format(R"({}, "{}" sum of heat reclaim recovery efficiencies from the same source coil: "{}" cannot be over 0.3)",
-                                           HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
+                                           HVAC::coilTypeNames[(int)heatingCoil.coilType],
                                            heatingCoil.Name,
                                            heatingCoil.ReclaimHeatingCoilName));
                             }
@@ -1523,7 +1468,7 @@ namespace HeatingCoils {
                                 ShowSevereError(
                                     state,
                                     format(R"({}, "{}" sum of heat reclaim recovery efficiencies from the same source coil: "{}" cannot be over 0.3)",
-                                           HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
+                                           HVAC::coilTypeNames[(int)heatingCoil.coilType],
                                            heatingCoil.Name,
                                            heatingCoil.ReclaimHeatingCoilName));
                             }
@@ -1543,7 +1488,7 @@ namespace HeatingCoils {
                         ShowSevereError(
                             state,
                             format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
-                                   HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
+                                   HVAC::coilTypeNames[(int)heatingCoil.coilType],
                                    heatingCoil.Name,
                                    heatingCoil.ReclaimHeatingCoilName));
                     }
@@ -1564,6 +1509,7 @@ namespace HeatingCoils {
                 state.dataHeatingCoils->ShowSingleWarning(CoilNum) = false;
             }
         }
+#endif // GET_OUT        
     }
 
     void SizeHeatingCoil(EnergyPlusData &state, int const CoilNum)
@@ -1590,8 +1536,6 @@ namespace HeatingCoils {
         static constexpr std::string_view RoutineName("SizeHeatingCoil: "); // include trailing blank space
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        std::string CompName;       // component name
-        std::string CompType;       // component type
         std::string SizingString;   // input field sizing description (e.g., Nominal Capacity)
         bool bPRINT = true;         // TRUE if sizing is reported to output (eio)
         Real64 NominalCapacityDes;  // Autosized nominal capacity for reporting
@@ -1600,40 +1544,38 @@ namespace HeatingCoils {
         int FieldNum = 2;           // IDD numeric field number where input field description is found
         int NumCoilsSized = 0;      // counter used to deallocate temporary string array after all coils have been sized
 
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+        auto &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
 
-        if (heatingCoil.HCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage) {
-            FieldNum = 1 + (heatingCoil.NumOfStages * 2);
-            TempCap = heatingCoil.MSNominalCapacity(heatingCoil.NumOfStages);
-        } else if (heatingCoil.HCoilType_Num == HVAC::Coil_HeatingGas_MultiStage) {
-            FieldNum = 1 + (heatingCoil.NumOfStages * 3);
-            TempCap = heatingCoil.MSNominalCapacity(heatingCoil.NumOfStages);
-        } else if (heatingCoil.HCoilType_Num == HVAC::Coil_HeatingDesuperheater) {
+        if (heatCoil.coilType == HVAC::CoilType::HeatingElectricMultiStage) {
+            FieldNum = 1 + (heatCoil.NumOfStages * 2);
+            TempCap = heatCoil.MSNominalCapacity(heatCoil.NumOfStages);
+        } else if (heatCoil.coilType == HVAC::CoilType::HeatingGasMultiStage) {
+            FieldNum = 1 + (heatCoil.NumOfStages * 3);
+            TempCap = heatCoil.MSNominalCapacity(heatCoil.NumOfStages);
+        } else if (heatCoil.coilType == HVAC::CoilType::HeatingDesuperheater) {
             return; // no autosizable inputs for desupterheater
         } else {
             FieldNum = 2;
-            TempCap = heatingCoil.NominalCapacity;
+            TempCap = heatCoil.NominalCapacity;
         }
         SizingString = state.dataHeatingCoils->HeatingCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [W]";
-        CompType = "Coil:" + heatingCoil.HeatingCoilType + ':' + heatingCoil.HeatingCoilModel;
-        CompName = heatingCoil.Name;
         state.dataSize->DataCoilIsSuppHeater = state.dataHeatingCoils->CoilIsSuppHeater; // set global instead of using optional argument
         state.dataSize->DataCoolCoilCap =
             0.0; // global only used for heat pump heating coils, non-HP heating coils are sized with other global variables
 
         if (TempCap == DataSizing::AutoSize) {
-            if (heatingCoil.DesiccantRegenerationCoil) {
+            if (heatCoil.DesiccantRegenerationCoil) {
                 state.dataSize->DataDesicRegCoil = true;
                 bPRINT = false;
-                state.dataSize->DataDesicDehumNum = heatingCoil.DesiccantDehumNum;
+                state.dataSize->DataDesicDehumNum = heatCoil.DesiccantDehumNum;
                 HeatingCoilDesAirInletTempSizer sizerHeatingDesInletTemp;
                 bool ErrorsFound = false;
-                sizerHeatingDesInletTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHeatingDesInletTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)heatCoil.coilType], heatCoil.Name, bPRINT, RoutineName);
                 state.dataSize->DataDesInletAirTemp = sizerHeatingDesInletTemp.size(state, DataSizing::AutoSize, ErrorsFound);
 
                 HeatingCoilDesAirOutletTempSizer sizerHeatingDesOutletTemp;
                 ErrorsFound = false;
-                sizerHeatingDesOutletTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHeatingDesOutletTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)heatCoil.coilType], heatCoil.Name, bPRINT, RoutineName);
                 state.dataSize->DataDesOutletAirTemp = sizerHeatingDesOutletTemp.size(state, DataSizing::AutoSize, ErrorsFound);
 
                 if (state.dataSize->CurOASysNum > 0) {
@@ -1648,39 +1590,40 @@ namespace HeatingCoils {
         bool errorsFound = false;
         HeatingCapacitySizer sizerHeatingCapacity;
         sizerHeatingCapacity.overrideSizingString(SizingString);
-        sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+        sizerHeatingCapacity.initializeWithinEP(state, HVAC::coilTypeNames[(int)heatCoil.coilType], heatCoil.Name, bPRINT, RoutineName);
         TempCap = sizerHeatingCapacity.size(state, TempCap, errorsFound);
         state.dataSize->DataCoilIsSuppHeater = false; // reset global to false so other heating coils are not affected
         state.dataSize->DataDesicRegCoil = false;     // reset global to false so other heating coils are not affected
         state.dataSize->DataDesInletAirTemp = 0.0;    // reset global data to zero so other heating coils are not
         state.dataSize->DataDesOutletAirTemp = 0.0;   // reset global data to zero so other heating coils are not affected
 
-        if (heatingCoil.HCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage || heatingCoil.HCoilType_Num == HVAC::Coil_HeatingGas_MultiStage) {
-            heatingCoil.MSNominalCapacity(heatingCoil.NumOfStages) = TempCap;
+        if (heatCoil.coilType == HVAC::CoilType::HeatingElectricMultiStage ||
+            heatCoil.coilType == HVAC::CoilType::HeatingGasMultiStage) {
+            heatCoil.MSNominalCapacity(heatCoil.NumOfStages) = TempCap;
             bool IsAutoSize = false;
             int NumOfStages; // total number of stages of multi-stage heating coil
-            if (any_eq(heatingCoil.MSNominalCapacity, DataSizing::AutoSize)) {
+            if (any_eq(heatCoil.MSNominalCapacity, DataSizing::AutoSize)) {
                 IsAutoSize = true;
             }
             if (IsAutoSize) {
-                NumOfStages = heatingCoil.NumOfStages;
+                NumOfStages = heatCoil.NumOfStages;
                 for (int StageNum = NumOfStages - 1; StageNum >= 1; --StageNum) {
                     bool ThisStageAutoSize = false;
-                    FieldNum = 1 + StageNum * ((heatingCoil.HCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage) ? 2 : 3);
+                    FieldNum = 1 + StageNum * ((heatCoil.coilType == HVAC::CoilType::HeatingElectricMultiStage) ? 2 : 3);
                     SizingString = state.dataHeatingCoils->HeatingCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [W]";
-                    if (heatingCoil.MSNominalCapacity(StageNum) == DataSizing::AutoSize) {
+                    if (heatCoil.MSNominalCapacity(StageNum) == DataSizing::AutoSize) {
                         ThisStageAutoSize = true;
                     }
                     NominalCapacityDes = TempCap * StageNum / NumOfStages;
                     if (ThisStageAutoSize) {
-                        heatingCoil.MSNominalCapacity(StageNum) = NominalCapacityDes;
-                        BaseSizer::reportSizerOutput(state, CompType, CompName, "Design Size " + SizingString, NominalCapacityDes);
+                        heatCoil.MSNominalCapacity(StageNum) = NominalCapacityDes;
+                        BaseSizer::reportSizerOutput(state, HVAC::coilTypeNames[(int)heatCoil.coilType], heatCoil.Name, "Design Size " + SizingString, NominalCapacityDes);
                     } else {
-                        if (heatingCoil.MSNominalCapacity(StageNum) > 0.0 && NominalCapacityDes > 0.0) {
+                        if (heatCoil.MSNominalCapacity(StageNum) > 0.0 && NominalCapacityDes > 0.0) {
                             NominalCapacityUser = TempCap * StageNum / NumOfStages; // HeatingCoil( CoilNum ).MSNominalCapacity( StageNum );
                             BaseSizer::reportSizerOutput(state,
-                                                         CompType,
-                                                         CompName,
+                                                         HVAC::coilTypeNames[(int)heatCoil.coilType],
+                                                         heatCoil.Name,
                                                          "Design Size " + SizingString,
                                                          NominalCapacityDes,
                                                          "User-Specified " + SizingString,
@@ -1689,7 +1632,7 @@ namespace HeatingCoils {
                                 if ((std::abs(NominalCapacityDes - NominalCapacityUser) / NominalCapacityUser) >
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
-                                                format("SizeHeatingCoil: Potential issue with equipment sizing for {}, {}", CompType, CompName));
+                                                format("SizeHeatingCoil: Potential issue with equipment sizing for {}, {}", HVAC::coilTypeNames[(int)heatCoil.coilType], heatCoil.Name));
                                     ShowContinueError(state, format("User-Specified Nominal Capacity of {:.2R} [W]", NominalCapacityUser));
                                     ShowContinueError(state, format("differs from Design Size Nominal Capacity of {:.2R} [W]", NominalCapacityDes));
                                     ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
@@ -1700,73 +1643,78 @@ namespace HeatingCoils {
                     }
                 }
             } else { // No autosize
-                NumOfStages = heatingCoil.NumOfStages;
+                NumOfStages = heatCoil.NumOfStages;
                 for (int StageNum = NumOfStages - 1; StageNum >= 1; --StageNum) {
-                    if (heatingCoil.MSNominalCapacity(StageNum) > 0.0) {
+                    if (heatCoil.MSNominalCapacity(StageNum) > 0.0) {
                         BaseSizer::reportSizerOutput(
-                            state, CompType, CompName, "User-Specified " + SizingString, heatingCoil.MSNominalCapacity(StageNum));
+                            state, HVAC::coilTypeNames[(int)heatCoil.coilType], heatCoil.Name, "User-Specified " + SizingString, heatCoil.MSNominalCapacity(StageNum));
                     }
                 }
             }
             // Ensure capacity at lower Stage must be lower or equal to the capacity at higher Stage.
-            for (int StageNum = 1; StageNum <= heatingCoil.NumOfStages - 1; ++StageNum) {
-                if (heatingCoil.MSNominalCapacity(StageNum) > heatingCoil.MSNominalCapacity(StageNum + 1)) {
+            for (int StageNum = 1; StageNum <= heatCoil.NumOfStages - 1; ++StageNum) {
+                if (heatCoil.MSNominalCapacity(StageNum) > heatCoil.MSNominalCapacity(StageNum + 1)) {
                     ShowSevereError(state,
                                     format("SizeHeatingCoil: {} {}, Stage {} Nominal Capacity ({:.2R} W) must be less than or equal to Stage {} "
                                            "Nominal Capacity ({:.2R} W).",
-                                           heatingCoil.HeatingCoilType,
-                                           heatingCoil.Name,
+                                           "Heating",
+                                           heatCoil.Name,
                                            StageNum,
-                                           heatingCoil.MSNominalCapacity(StageNum),
+                                           heatCoil.MSNominalCapacity(StageNum),
                                            StageNum + 1,
-                                           heatingCoil.MSNominalCapacity(StageNum + 1)));
+                                           heatCoil.MSNominalCapacity(StageNum + 1)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
                 }
             }
         } else { // not a multi-speed coil
-            heatingCoil.NominalCapacity = TempCap;
+            heatCoil.NominalCapacity = TempCap;
         }
 
         if (++NumCoilsSized == state.dataHeatingCoils->NumHeatingCoils)
             state.dataHeatingCoils->HeatingCoilNumericFields.deallocate(); // remove temporary array for field names at end of sizing
 
         // create predefined report entries
-        switch (heatingCoil.HCoilType_Num) {
-        case HVAC::Coil_HeatingElectric: {
-            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilType, heatingCoil.Name, "Coil:Heating:Electric");
+        switch (heatCoil.coilType) {
+        case HVAC::CoilType::HeatingElectric: {
+            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilType, heatCoil.Name, "Coil:Heating:Electric");
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatingCoil.Name, heatingCoil.NominalCapacity);
-            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatingCoil.Name, heatingCoil.Efficiency);
+                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatCoil.Name, heatCoil.NominalCapacity);
+            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatCoil.Name, heatCoil.Efficiency);
         } break;
-        case HVAC::Coil_HeatingElectric_MultiStage: {
+
+        case HVAC::CoilType::HeatingElectricMultiStage: {
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilType, heatingCoil.Name, "Coil:Heating:Electric:MultiStage");
+                state, state.dataOutRptPredefined->pdchHeatCoilType, heatCoil.Name, "Coil:Heating:Electric:MultiStage");
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatingCoil.Name, heatingCoil.MSNominalCapacity(heatingCoil.NumOfStages));
+                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatCoil.Name, heatCoil.MSNominalCapacity(heatCoil.NumOfStages));
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatingCoil.Name, heatingCoil.MSEfficiency(heatingCoil.NumOfStages));
+                state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatCoil.Name, heatCoil.MSEfficiency(heatCoil.NumOfStages));
         } break;
-        case HVAC::Coil_HeatingGasOrOtherFuel: {
-            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilType, heatingCoil.Name, "Coil:Heating:Fuel");
+
+        case HVAC::CoilType::HeatingGasOrOtherFuel: {
+            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilType, heatCoil.Name, "Coil:Heating:Fuel");
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatingCoil.Name, heatingCoil.NominalCapacity);
-            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatingCoil.Name, heatingCoil.Efficiency);
+                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatCoil.Name, heatCoil.NominalCapacity);
+            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatCoil.Name, heatCoil.Efficiency);
         } break;
-        case HVAC::Coil_HeatingGas_MultiStage: {
+          
+        case HVAC::CoilType::HeatingGasMultiStage: {
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilType, heatingCoil.Name, "Coil:Heating:Gas:MultiStage");
+                state, state.dataOutRptPredefined->pdchHeatCoilType, heatCoil.Name, "Coil:Heating:Gas:MultiStage");
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatingCoil.Name, heatingCoil.MSNominalCapacity(heatingCoil.NumOfStages));
+                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatCoil.Name, heatCoil.MSNominalCapacity(heatCoil.NumOfStages));
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatingCoil.Name, heatingCoil.MSEfficiency(heatingCoil.NumOfStages));
+                state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatCoil.Name, heatCoil.MSEfficiency(heatCoil.NumOfStages));
         } break;
-        case HVAC::Coil_HeatingDesuperheater: {
+          
+        case HVAC::CoilType::HeatingDesuperheater: {
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilType, heatingCoil.Name, "Coil:Heating:Desuperheater");
+                state, state.dataOutRptPredefined->pdchHeatCoilType, heatCoil.Name, "Coil:Heating:Desuperheater");
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatingCoil.Name, heatingCoil.NominalCapacity);
-            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatingCoil.Name, heatingCoil.Efficiency);
+                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, heatCoil.Name, heatCoil.NominalCapacity);
+            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, heatCoil.Name, heatCoil.Efficiency);
         } break;
+
         default:
             break;
         }
@@ -1799,33 +1747,33 @@ namespace HeatingCoils {
         Real64 HeatingCoilLoad;
         Real64 QCoilCap;
 
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+        auto &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
 
-        Real64 Effic = heatingCoil.Efficiency;
-        Real64 TempAirIn = heatingCoil.InletAirTemp;
-        Real64 Win = heatingCoil.InletAirHumRat;
-        Real64 TempSetPoint = heatingCoil.DesiredOutletTemp;
+        Real64 Effic = heatCoil.Efficiency;
+        Real64 TempAirIn = heatCoil.InletAirTemp;
+        Real64 Win = heatCoil.InletAirHumRat;
+        Real64 TempSetPoint = heatCoil.DesiredOutletTemp;
 
         // If there is a fault of coil SAT Sensor
-        if (heatingCoil.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
+        if (heatCoil.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
             (!state.dataGlobal->KickOffSimulation)) {
             // calculate the sensor offset using fault information
-            int FaultIndex = heatingCoil.FaultyCoilSATIndex;
-            heatingCoil.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
+            int FaultIndex = heatCoil.FaultyCoilSATIndex;
+            heatCoil.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
             // update the TempSetPoint
-            TempSetPoint -= heatingCoil.FaultyCoilSATOffset;
+            TempSetPoint -= heatCoil.FaultyCoilSATOffset;
         }
 
         //  adjust mass flow rates for cycling fan cycling coil operation
         if (fanOp == HVAC::FanOp::Cycling) {
             if (PartLoadRatio > 0.0) {
-                AirMassFlow = heatingCoil.InletAirMassFlowRate / PartLoadRatio;
+                AirMassFlow = heatCoil.InletAirMassFlowRate / PartLoadRatio;
                 QCoilReq /= PartLoadRatio;
             } else {
                 AirMassFlow = 0.0;
             }
         } else {
-            AirMassFlow = heatingCoil.InletAirMassFlowRate;
+            AirMassFlow = heatCoil.InletAirMassFlowRate;
         }
 
         Real64 CapacitanceAir = Psychrometrics::PsyCpAirFnW(Win) * AirMassFlow;
@@ -1835,11 +1783,11 @@ namespace HeatingCoils {
         //  Also the coil has to be scheduled to be available.
 
         // Control output to meet load QCoilReq (QCoilReq is passed in if load controlled, otherwise QCoilReq=-999)
-        if ((AirMassFlow > 0.0 && heatingCoil.NominalCapacity > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) && (QCoilReq > 0.0)) {
+        if ((AirMassFlow > 0.0 && heatCoil.NominalCapacity > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) && (QCoilReq > 0.0)) {
 
             // check to see if the Required heating capacity is greater than the user specified capacity.
-            if (QCoilReq > heatingCoil.NominalCapacity) {
-                QCoilCap = heatingCoil.NominalCapacity;
+            if (QCoilReq > heatCoil.NominalCapacity) {
+                QCoilCap = heatCoil.NominalCapacity;
             } else {
                 QCoilCap = QCoilReq;
             }
@@ -1848,10 +1796,10 @@ namespace HeatingCoils {
             HeatingCoilLoad = QCoilCap;
 
             // The HeatingCoilLoad is the change in the enthalpy of the Heating
-            heatingCoil.ElecUseLoad = HeatingCoilLoad / Effic;
+            heatCoil.ElecUseLoad = HeatingCoilLoad / Effic;
 
             // Control coil output to meet a setpoint temperature.
-        } else if ((AirMassFlow > 0.0 && heatingCoil.NominalCapacity > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) &&
+        } else if ((AirMassFlow > 0.0 && heatCoil.NominalCapacity > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) &&
                    (QCoilReq == DataLoopNode::SensedLoadFlagValue) && (std::abs(TempSetPoint - TempAirIn) > HVAC::TempControlTol)) {
 
             QCoilCap = CapacitanceAir * (TempSetPoint - TempAirIn);
@@ -1862,8 +1810,8 @@ namespace HeatingCoils {
                 TempAirOut = TempAirIn;
                 // check to see if the Required heating capacity is greater than the user
                 // specified capacity.
-            } else if (QCoilCap > heatingCoil.NominalCapacity) {
-                QCoilCap = heatingCoil.NominalCapacity;
+            } else if (QCoilCap > heatCoil.NominalCapacity) {
+                QCoilCap = heatCoil.NominalCapacity;
                 TempAirOut = TempAirIn + QCoilCap / CapacitanceAir;
             } else {
                 TempAirOut = TempSetPoint;
@@ -1872,47 +1820,47 @@ namespace HeatingCoils {
             HeatingCoilLoad = QCoilCap;
 
             // The HeatingCoilLoad is the change in the enthalpy of the Heating
-            heatingCoil.ElecUseLoad = HeatingCoilLoad / Effic;
+            heatCoil.ElecUseLoad = HeatingCoilLoad / Effic;
 
         } else { // If not running Conditions do not change across coil from inlet to outlet
 
             TempAirOut = TempAirIn;
             HeatingCoilLoad = 0.0;
-            heatingCoil.ElecUseLoad = 0.0;
+            heatCoil.ElecUseLoad = 0.0;
         }
 
         if (fanOp == HVAC::FanOp::Cycling) {
-            heatingCoil.ElecUseLoad *= PartLoadRatio;
+            heatCoil.ElecUseLoad *= PartLoadRatio;
             HeatingCoilLoad *= PartLoadRatio;
         }
 
-        heatingCoil.HeatingCoilLoad = HeatingCoilLoad;
+        heatCoil.HeatingCoilLoad = HeatingCoilLoad;
 
         // Set the outlet conditions
-        heatingCoil.OutletAirTemp = TempAirOut;
+        heatCoil.OutletAirTemp = TempAirOut;
 
         // This HeatingCoil does not change the moisture or Mass Flow across the component
-        heatingCoil.OutletAirHumRat = heatingCoil.InletAirHumRat;
-        heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+        heatCoil.OutletAirHumRat = heatCoil.InletAirHumRat;
+        heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
         // Set the outlet enthalpys for air and Heating
-        heatingCoil.OutletAirEnthalpy = Psychrometrics::PsyHFnTdbW(heatingCoil.OutletAirTemp, heatingCoil.OutletAirHumRat);
+        heatCoil.OutletAirEnthalpy = Psychrometrics::PsyHFnTdbW(heatCoil.OutletAirTemp, heatCoil.OutletAirHumRat);
 
         QCoilActual = HeatingCoilLoad;
-        if (std::abs(heatingCoil.NominalCapacity) < 1.e-8) {
-            if (heatingCoil.AirLoopNum > 0) {
-                state.dataAirLoop->AirLoopAFNInfo(heatingCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF =
-                    max(state.dataAirLoop->AirLoopAFNInfo(heatingCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF, 0.0);
+        if (std::abs(heatCoil.NominalCapacity) < 1.e-8) {
+            if (heatCoil.AirLoopNum > 0) {
+                state.dataAirLoop->AirLoopAFNInfo(heatCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF =
+                    max(state.dataAirLoop->AirLoopAFNInfo(heatCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF, 0.0);
             }
         } else {
-            if (heatingCoil.AirLoopNum > 0) {
-                state.dataAirLoop->AirLoopAFNInfo(heatingCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF =
-                    max(state.dataAirLoop->AirLoopAFNInfo(heatingCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF,
-                        HeatingCoilLoad / heatingCoil.NominalCapacity);
+            if (heatCoil.AirLoopNum > 0) {
+                state.dataAirLoop->AirLoopAFNInfo(heatCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF =
+                    max(state.dataAirLoop->AirLoopAFNInfo(heatCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF,
+                        HeatingCoilLoad / heatCoil.NominalCapacity);
             }
         }
 
         // set outlet node temp so parent objects can call calc directly without have to simulate entire model
-        state.dataLoopNodes->Node(heatingCoil.AirOutletNodeNum).Temp = heatingCoil.OutletAirTemp;
+        state.dataLoopNodes->Node(heatCoil.AirOutletNodeNum).Temp = heatCoil.OutletAirTemp;
     }
 
     void CalcMultiStageElectricHeatingCoil(EnergyPlusData &state,
@@ -1962,35 +1910,35 @@ namespace HeatingCoils {
         Real64 HSElecHeatingPower;   // Full load power at high stage
         Real64 PartLoadRat;          // part load ratio
 
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+        auto &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
         if (StageNum > 1) {
             StageNumLS = StageNum - 1;
             StageNumHS = StageNum;
-            if (StageNum > heatingCoil.NumOfStages) {
-                StageNumLS = heatingCoil.NumOfStages - 1;
-                StageNumHS = heatingCoil.NumOfStages;
+            if (StageNum > heatCoil.NumOfStages) {
+                StageNumLS = heatCoil.NumOfStages - 1;
+                StageNumHS = heatCoil.NumOfStages;
             }
         } else {
             StageNumLS = 1;
             StageNumHS = 1;
         }
 
-        Real64 AirMassFlow = heatingCoil.InletAirMassFlowRate;
-        Real64 InletAirDryBulbTemp = heatingCoil.InletAirTemp;
-        Real64 InletAirEnthalpy = heatingCoil.InletAirEnthalpy;
-        Real64 InletAirHumRat = heatingCoil.InletAirHumRat;
+        Real64 AirMassFlow = heatCoil.InletAirMassFlowRate;
+        Real64 InletAirDryBulbTemp = heatCoil.InletAirTemp;
+        Real64 InletAirEnthalpy = heatCoil.InletAirEnthalpy;
+        Real64 InletAirHumRat = heatCoil.InletAirHumRat;
 
         Real64 OutdoorPressure = state.dataEnvrn->OutBaroPress;
 
-        if ((AirMassFlow > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) && ((CycRatio > 0.0) || (SpeedRatio > 0.0))) {
+        if ((AirMassFlow > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) && ((CycRatio > 0.0) || (SpeedRatio > 0.0))) {
 
             if (StageNum > 1) {
 
-                TotCapLS = heatingCoil.MSNominalCapacity(StageNumLS);
-                TotCapHS = heatingCoil.MSNominalCapacity(StageNumHS);
+                TotCapLS = heatCoil.MSNominalCapacity(StageNumLS);
+                TotCapHS = heatCoil.MSNominalCapacity(StageNumHS);
 
-                EffLS = heatingCoil.MSEfficiency(StageNumLS);
-                EffHS = heatingCoil.MSEfficiency(StageNumHS);
+                EffLS = heatCoil.MSEfficiency(StageNumLS);
+                EffHS = heatCoil.MSEfficiency(StageNumHS);
 
                 // Get full load output and power
                 LSElecHeatingPower = TotCapLS / EffLS;
@@ -2001,11 +1949,11 @@ namespace HeatingCoils {
                 // IF (FanOpMode .EQ. FanOp::Cycling) OnOffFanPartLoadFraction = 1.0d0
 
                 // Power calculation
-                heatingCoil.ElecUseLoad = SpeedRatio * HSElecHeatingPower + (1.0 - SpeedRatio) * LSElecHeatingPower;
+                heatCoil.ElecUseLoad = SpeedRatio * HSElecHeatingPower + (1.0 - SpeedRatio) * LSElecHeatingPower;
 
-                heatingCoil.HeatingCoilLoad = TotCapHS * SpeedRatio + TotCapLS * (1.0 - SpeedRatio);
+                heatCoil.HeatingCoilLoad = TotCapHS * SpeedRatio + TotCapLS * (1.0 - SpeedRatio);
 
-                OutletAirEnthalpy = InletAirEnthalpy + heatingCoil.HeatingCoilLoad / heatingCoil.InletAirMassFlowRate;
+                OutletAirEnthalpy = InletAirEnthalpy + heatCoil.HeatingCoilLoad / heatCoil.InletAirMassFlowRate;
                 OutletAirTemp = Psychrometrics::PsyTdbFnHW(OutletAirEnthalpy, OutletAirHumRat);
                 FullLoadOutAirRH = Psychrometrics::PsyRhFnTdbWPb(state, OutletAirTemp, OutletAirHumRat, OutdoorPressure, RoutineNameAverageLoad);
 
@@ -2014,10 +1962,10 @@ namespace HeatingCoils {
                     OutletAirHumRat = Psychrometrics::PsyWFnTdbH(state, OutletAirTemp, OutletAirEnthalpy, RoutineName);
                 }
 
-                heatingCoil.OutletAirTemp = OutletAirTemp;
-                heatingCoil.OutletAirHumRat = OutletAirHumRat;
-                heatingCoil.OutletAirEnthalpy = OutletAirEnthalpy;
-                heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+                heatCoil.OutletAirTemp = OutletAirTemp;
+                heatCoil.OutletAirHumRat = OutletAirHumRat;
+                heatCoil.OutletAirEnthalpy = OutletAirEnthalpy;
+                heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
 
                 // Stage 1
             } else if (CycRatio > 0.0) {
@@ -2033,7 +1981,7 @@ namespace HeatingCoils {
                     }
                 }
 
-                TotCap = heatingCoil.MSNominalCapacity(StageNumLS);
+                TotCap = heatCoil.MSNominalCapacity(StageNumLS);
 
                 // Calculate full load outlet conditions
                 FullLoadOutAirEnth = InletAirEnthalpy + TotCap / AirMassFlow;
@@ -2060,18 +2008,18 @@ namespace HeatingCoils {
                     OutletAirTemp = PartLoadRat * FullLoadOutAirTemp + (1.0 - PartLoadRat) * InletAirDryBulbTemp;
                 }
 
-                EffLS = heatingCoil.MSEfficiency(StageNumLS);
+                EffLS = heatCoil.MSEfficiency(StageNumLS);
 
                 //    HeatingCoil(CoilNum)%HeatingCoilLoad = TotCap
                 //   This would require a CR to change
-                heatingCoil.HeatingCoilLoad = TotCap * PartLoadRat;
+                heatCoil.HeatingCoilLoad = TotCap * PartLoadRat;
 
-                heatingCoil.ElecUseLoad = heatingCoil.HeatingCoilLoad / EffLS;
+                heatCoil.ElecUseLoad = heatCoil.HeatingCoilLoad / EffLS;
 
-                heatingCoil.OutletAirTemp = OutletAirTemp;
-                heatingCoil.OutletAirHumRat = OutletAirHumRat;
-                heatingCoil.OutletAirEnthalpy = OutletAirEnthalpy;
-                heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+                heatCoil.OutletAirTemp = OutletAirTemp;
+                heatCoil.OutletAirHumRat = OutletAirHumRat;
+                heatCoil.OutletAirEnthalpy = OutletAirEnthalpy;
+                heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
                 // this would require a CR to correct (i.e., calculate outputs when coil is off)
                 //  ELSE
                 //    ! electric coil is off; just pass through conditions
@@ -2087,21 +2035,21 @@ namespace HeatingCoils {
         } else {
 
             // electric coil is off; just pass through conditions
-            heatingCoil.OutletAirEnthalpy = heatingCoil.InletAirEnthalpy;
-            heatingCoil.OutletAirHumRat = heatingCoil.InletAirHumRat;
-            heatingCoil.OutletAirTemp = heatingCoil.InletAirTemp;
-            heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+            heatCoil.OutletAirEnthalpy = heatCoil.InletAirEnthalpy;
+            heatCoil.OutletAirHumRat = heatCoil.InletAirHumRat;
+            heatCoil.OutletAirTemp = heatCoil.InletAirTemp;
+            heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
 
             // some of these are reset in Init, can be removed to speed up code
-            heatingCoil.ElecUseLoad = 0.0;
-            heatingCoil.HeatingCoilLoad = 0.0;
+            heatCoil.ElecUseLoad = 0.0;
+            heatCoil.HeatingCoilLoad = 0.0;
 
         } // end of on/off if - else
 
         // set outlet node temp so parent objects can call calc directly without have to simulate entire model
-        state.dataLoopNodes->Node(heatingCoil.AirOutletNodeNum).Temp = heatingCoil.OutletAirTemp;
+        state.dataLoopNodes->Node(heatCoil.AirOutletNodeNum).Temp = heatCoil.OutletAirTemp;
 
-        QCoilActual = heatingCoil.HeatingCoilLoad;
+        QCoilActual = heatCoil.HeatingCoilLoad;
     }
 
     void CalcFuelHeatingCoil(EnergyPlusData &state,
@@ -2127,24 +2075,24 @@ namespace HeatingCoils {
         Real64 PartLoadRat;
         Real64 PLF;
 
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+        auto &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
 
-        Real64 Effic = heatingCoil.Efficiency;
-        Real64 TempAirIn = heatingCoil.InletAirTemp;
-        Real64 Win = heatingCoil.InletAirHumRat;
-        Real64 TempSetPoint = heatingCoil.DesiredOutletTemp;
-        Real64 AirMassFlow = heatingCoil.InletAirMassFlowRate;
+        Real64 Effic = heatCoil.Efficiency;
+        Real64 TempAirIn = heatCoil.InletAirTemp;
+        Real64 Win = heatCoil.InletAirHumRat;
+        Real64 TempSetPoint = heatCoil.DesiredOutletTemp;
+        Real64 AirMassFlow = heatCoil.InletAirMassFlowRate;
 
         Real64 CapacitanceAir = Psychrometrics::PsyCpAirFnW(Win) * AirMassFlow;
 
         // If there is a fault of coil SAT Sensor
-        if (heatingCoil.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
+        if (heatCoil.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
             (!state.dataGlobal->KickOffSimulation)) {
             // calculate the sensor offset using fault information
-            int FaultIndex = heatingCoil.FaultyCoilSATIndex;
-            heatingCoil.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
+            int FaultIndex = heatCoil.FaultyCoilSATIndex;
+            heatCoil.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
             // update the TempSetPoint
-            TempSetPoint -= heatingCoil.FaultyCoilSATOffset;
+            TempSetPoint -= heatCoil.FaultyCoilSATOffset;
         }
 
         // If the coil is operating there should be some heating capacitance
@@ -2152,11 +2100,11 @@ namespace HeatingCoils {
         //  Also the coil has to be scheduled to be available.
 
         // Control output to meet load QCoilReq (QCoilReq is passed in if load controlled, otherwise QCoilReq=-999)
-        if ((AirMassFlow > 0.0 && heatingCoil.NominalCapacity > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) && (QCoilReq > 0.0)) {
+        if ((AirMassFlow > 0.0 && heatCoil.NominalCapacity > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) && (QCoilReq > 0.0)) {
 
             // check to see if the Required heating capacity is greater than the user specified capacity.
-            if (QCoilReq > heatingCoil.NominalCapacity) {
-                QCoilCap = heatingCoil.NominalCapacity;
+            if (QCoilReq > heatCoil.NominalCapacity) {
+                QCoilCap = heatCoil.NominalCapacity;
             } else {
                 QCoilCap = QCoilReq;
             }
@@ -2164,15 +2112,15 @@ namespace HeatingCoils {
             TempAirOut = TempAirIn + QCoilCap / CapacitanceAir;
             HeatingCoilLoad = QCoilCap;
 
-            PartLoadRat = HeatingCoilLoad / heatingCoil.NominalCapacity;
+            PartLoadRat = HeatingCoilLoad / heatCoil.NominalCapacity;
 
             // The HeatingCoilLoad is the change in the enthalpy of the Heating
-            heatingCoil.FuelUseLoad = HeatingCoilLoad / Effic;
-            heatingCoil.ElecUseLoad = heatingCoil.ParasiticElecLoad * PartLoadRat;
-            heatingCoil.ParasiticFuelRate = heatingCoil.ParasiticFuelCapacity * (1.0 - PartLoadRat);
+            heatCoil.FuelUseLoad = HeatingCoilLoad / Effic;
+            heatCoil.ElecUseLoad = heatCoil.ParasiticElecLoad * PartLoadRat;
+            heatCoil.ParasiticFuelRate = heatCoil.ParasiticFuelCapacity * (1.0 - PartLoadRat);
 
             // Control coil output to meet a setpoint temperature.
-        } else if ((AirMassFlow > 0.0 && heatingCoil.NominalCapacity > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) &&
+        } else if ((AirMassFlow > 0.0 && heatCoil.NominalCapacity > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) &&
                    (QCoilReq == DataLoopNode::SensedLoadFlagValue) && (std::abs(TempSetPoint - TempAirIn) > HVAC::TempControlTol)) {
 
             QCoilCap = CapacitanceAir * (TempSetPoint - TempAirIn);
@@ -2183,8 +2131,8 @@ namespace HeatingCoils {
                 TempAirOut = TempAirIn;
                 // check to see if the Required heating capacity is greater than the user
                 // specified capacity.
-            } else if (QCoilCap > heatingCoil.NominalCapacity) {
-                QCoilCap = heatingCoil.NominalCapacity;
+            } else if (QCoilCap > heatCoil.NominalCapacity) {
+                QCoilCap = heatCoil.NominalCapacity;
                 TempAirOut = TempAirIn + QCoilCap / CapacitanceAir;
             } else {
                 TempAirOut = TempSetPoint;
@@ -2192,73 +2140,73 @@ namespace HeatingCoils {
 
             HeatingCoilLoad = QCoilCap;
 
-            PartLoadRat = HeatingCoilLoad / heatingCoil.NominalCapacity;
+            PartLoadRat = HeatingCoilLoad / heatCoil.NominalCapacity;
 
             // The HeatingCoilLoad is the change in the enthalpy of the Heating
-            heatingCoil.FuelUseLoad = HeatingCoilLoad / Effic;
-            heatingCoil.ElecUseLoad = heatingCoil.ParasiticElecLoad * PartLoadRat;
-            heatingCoil.ParasiticFuelRate = heatingCoil.ParasiticFuelCapacity * (1.0 - PartLoadRat);
+            heatCoil.FuelUseLoad = HeatingCoilLoad / Effic;
+            heatCoil.ElecUseLoad = heatCoil.ParasiticElecLoad * PartLoadRat;
+            heatCoil.ParasiticFuelRate = heatCoil.ParasiticFuelCapacity * (1.0 - PartLoadRat);
 
         } else { // If not running Conditions do not change across coil from inlet to outlet
 
             TempAirOut = TempAirIn;
             HeatingCoilLoad = 0.0;
             PartLoadRat = 0.0;
-            heatingCoil.FuelUseLoad = 0.0;
-            heatingCoil.ElecUseLoad = 0.0;
-            heatingCoil.ParasiticFuelRate = heatingCoil.ParasiticFuelCapacity;
+            heatCoil.FuelUseLoad = 0.0;
+            heatCoil.ElecUseLoad = 0.0;
+            heatCoil.ParasiticFuelRate = heatCoil.ParasiticFuelCapacity;
         }
 
-        heatingCoil.RTF = PartLoadRat;
+        heatCoil.RTF = PartLoadRat;
 
         // If the PLF curve is defined the gas usage needs to be modified
-        if (heatingCoil.PLFCurveIndex > 0) {
+        if (heatCoil.PLFCurveIndex > 0) {
             if (PartLoadRat == 0) {
-                heatingCoil.FuelUseLoad = 0.0;
+                heatCoil.FuelUseLoad = 0.0;
             } else {
-                PLF = Curve::CurveValue(state, heatingCoil.PLFCurveIndex, PartLoadRat);
+                PLF = Curve::CurveValue(state, heatCoil.PLFCurveIndex, PartLoadRat);
                 if (PLF < 0.7) {
-                    if (heatingCoil.PLFErrorCount < 1) {
-                        ++heatingCoil.PLFErrorCount;
+                    if (heatCoil.PLFErrorCount < 1) {
+                        ++heatCoil.PLFErrorCount;
                         ShowWarningError(state,
                                          format("CalcFuelHeatingCoil: {}=\"{}\", PLF curve values",
-                                                HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                                heatingCoil.Name));
+                                                HVAC::coilTypeNames[(int)heatCoil.coilType],
+                                                heatCoil.Name));
                         ShowContinueError(state, format("The PLF curve value = {:.5T} for part-load ratio = {:.5T}", PLF, PartLoadRat));
                         ShowContinueError(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and the simulation continues...");
                         ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:Fuel].");
                     } else {
                         ShowRecurringWarningErrorAtEnd(
-                            state, heatingCoil.Name + ", Heating coil PLF curve < 0.7 warning continues... ", heatingCoil.PLFErrorIndex, PLF, PLF);
+                            state, heatCoil.Name + ", Heating coil PLF curve < 0.7 warning continues... ", heatCoil.PLFErrorIndex, PLF, PLF);
                     }
                     PLF = 0.7;
                 }
                 // Modify the Gas Coil Consumption and parasitic loads based on PLF curve
-                heatingCoil.RTF = PartLoadRat / PLF;
-                if (heatingCoil.RTF > 1.0 && std::abs(heatingCoil.RTF - 1.0) > 0.001) {
-                    if (heatingCoil.RTFErrorCount < 1) {
-                        ++heatingCoil.RTFErrorCount;
+                heatCoil.RTF = PartLoadRat / PLF;
+                if (heatCoil.RTF > 1.0 && std::abs(heatCoil.RTF - 1.0) > 0.001) {
+                    if (heatCoil.RTFErrorCount < 1) {
+                        ++heatCoil.RTFErrorCount;
                         ShowWarningError(state,
                                          format("CalcFuelHeatingCoil: {}=\"{}\", runtime fraction",
-                                                HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                                heatingCoil.Name));
-                        ShowContinueError(state, format("The runtime fraction exceeded 1.0. [{:.4T}].", heatingCoil.RTF));
+                                                HVAC::coilTypeNames[(int)heatCoil.coilType],
+                                                heatCoil.Name));
+                        ShowContinueError(state, format("The runtime fraction exceeded 1.0. [{:.4T}].", heatCoil.RTF));
                         ShowContinueError(state, "Runtime fraction is set to 1.0 and the simulation continues...");
                         ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:Fuel].");
                     } else {
                         ShowRecurringWarningErrorAtEnd(state,
-                                                       format("{}, Heating coil runtime fraction > 1.0 warning continues... ", heatingCoil.Name),
-                                                       heatingCoil.RTFErrorIndex,
-                                                       heatingCoil.RTF,
-                                                       heatingCoil.RTF);
+                                                       format("{}, Heating coil runtime fraction > 1.0 warning continues... ", heatCoil.Name),
+                                                       heatCoil.RTFErrorIndex,
+                                                       heatCoil.RTF,
+                                                       heatCoil.RTF);
                     }
-                    heatingCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
-                } else if (heatingCoil.RTF > 1.0) {
-                    heatingCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
+                    heatCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
+                } else if (heatCoil.RTF > 1.0) {
+                    heatCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
                 }
-                heatingCoil.ElecUseLoad = heatingCoil.ParasiticElecLoad * heatingCoil.RTF;
-                heatingCoil.FuelUseLoad = heatingCoil.NominalCapacity / Effic * heatingCoil.RTF;
-                heatingCoil.ParasiticFuelRate = heatingCoil.ParasiticFuelCapacity * (1.0 - heatingCoil.RTF);
+                heatCoil.ElecUseLoad = heatCoil.ParasiticElecLoad * heatCoil.RTF;
+                heatCoil.FuelUseLoad = heatCoil.NominalCapacity / Effic * heatCoil.RTF;
+                heatCoil.ParasiticFuelRate = heatCoil.ParasiticFuelCapacity * (1.0 - heatCoil.RTF);
                 // Fan power will also be modified by the heating coil's part load fraction
                 // OnOffFanPartLoadFraction passed to fan via DataHVACGlobals (cycling fan only)
                 if (fanOp == HVAC::FanOp::Cycling) {
@@ -2268,24 +2216,24 @@ namespace HeatingCoils {
         }
 
         // Set the outlet conditions
-        heatingCoil.HeatingCoilLoad = HeatingCoilLoad;
-        heatingCoil.OutletAirTemp = TempAirOut;
+        heatCoil.HeatingCoilLoad = HeatingCoilLoad;
+        heatCoil.OutletAirTemp = TempAirOut;
 
         // This HeatingCoil does not change the moisture or Mass Flow across the component
-        heatingCoil.OutletAirHumRat = heatingCoil.InletAirHumRat;
-        heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+        heatCoil.OutletAirHumRat = heatCoil.InletAirHumRat;
+        heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
         // Set the outlet enthalpys for air and Heating
-        heatingCoil.OutletAirEnthalpy = Psychrometrics::PsyHFnTdbW(heatingCoil.OutletAirTemp, heatingCoil.OutletAirHumRat);
+        heatCoil.OutletAirEnthalpy = Psychrometrics::PsyHFnTdbW(heatCoil.OutletAirTemp, heatCoil.OutletAirHumRat);
 
         QCoilActual = HeatingCoilLoad;
-        if (heatingCoil.AirLoopNum > 0) {
-            state.dataAirLoop->AirLoopAFNInfo(heatingCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF =
-                max(state.dataAirLoop->AirLoopAFNInfo(heatingCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF, heatingCoil.RTF);
+        if (heatCoil.AirLoopNum > 0) {
+            state.dataAirLoop->AirLoopAFNInfo(heatCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF =
+                max(state.dataAirLoop->AirLoopAFNInfo(heatCoil.AirLoopNum).AFNLoopHeatingCoilMaxRTF, heatCoil.RTF);
         }
-        state.dataHVACGlobal->ElecHeatingCoilPower = heatingCoil.ElecUseLoad;
+        state.dataHVACGlobal->ElecHeatingCoilPower = heatCoil.ElecUseLoad;
 
         // set outlet node temp so parent objects can call calc directly without have to simulate entire model
-        state.dataLoopNodes->Node(heatingCoil.AirOutletNodeNum).Temp = heatingCoil.OutletAirTemp;
+        state.dataLoopNodes->Node(heatCoil.AirOutletNodeNum).Temp = heatCoil.OutletAirTemp;
     }
 
     void CalcMultiStageGasHeatingCoil(EnergyPlusData &state,
@@ -2341,37 +2289,37 @@ namespace HeatingCoils {
         Real64 PartLoadRat(0.0);     // part load ratio
         Real64 PLF;                  // part load factor used to calculate RTF
 
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+        auto &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
 
         if (StageNum > 1) {
             StageNumLS = StageNum - 1;
             StageNumHS = StageNum;
-            if (StageNum > heatingCoil.NumOfStages) {
-                StageNumLS = heatingCoil.NumOfStages - 1;
-                StageNumHS = heatingCoil.NumOfStages;
+            if (StageNum > heatCoil.NumOfStages) {
+                StageNumLS = heatCoil.NumOfStages - 1;
+                StageNumHS = heatCoil.NumOfStages;
             }
         } else {
             StageNumLS = 1;
             StageNumHS = 1;
         }
 
-        Real64 AirMassFlow = heatingCoil.InletAirMassFlowRate;
-        Real64 InletAirEnthalpy = heatingCoil.InletAirEnthalpy;
-        Real64 InletAirHumRat = heatingCoil.InletAirHumRat;
+        Real64 AirMassFlow = heatCoil.InletAirMassFlowRate;
+        Real64 InletAirEnthalpy = heatCoil.InletAirEnthalpy;
+        Real64 InletAirHumRat = heatCoil.InletAirHumRat;
         Real64 OutdoorPressure = state.dataEnvrn->OutBaroPress;
 
-        if ((AirMassFlow > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) && ((CycRatio > 0.0) || (SpeedRatio > 0.0))) {
+        if ((AirMassFlow > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) && ((CycRatio > 0.0) || (SpeedRatio > 0.0))) {
 
             if (StageNum > 1) {
 
-                TotCapLS = heatingCoil.MSNominalCapacity(StageNumLS);
-                TotCapHS = heatingCoil.MSNominalCapacity(StageNumHS);
+                TotCapLS = heatCoil.MSNominalCapacity(StageNumLS);
+                TotCapHS = heatCoil.MSNominalCapacity(StageNumHS);
 
-                EffLS = heatingCoil.MSEfficiency(StageNumLS);
-                EffHS = heatingCoil.MSEfficiency(StageNumHS);
+                EffLS = heatCoil.MSEfficiency(StageNumLS);
+                EffHS = heatCoil.MSEfficiency(StageNumHS);
 
                 PartLoadRat = min(1.0, SpeedRatio);
-                heatingCoil.RTF = 1.0;
+                heatCoil.RTF = 1.0;
 
                 // Get full load output and power
                 LSFullLoadOutAirEnth = InletAirEnthalpy + TotCapLS / MSHPMassFlowRateLow;
@@ -2384,17 +2332,17 @@ namespace HeatingCoils {
                 // IF (FanOpMode .EQ. FanOp::Cycling) OnOffFanPartLoadFraction = 1.0d0
 
                 // Power calculation. If PartLoadRat (SpeedRatio) = 0, operate at LS the whole time step
-                heatingCoil.ElecUseLoad =
-                    PartLoadRat * heatingCoil.MSParasiticElecLoad(StageNumHS) + (1.0 - PartLoadRat) * heatingCoil.MSParasiticElecLoad(StageNumLS);
+                heatCoil.ElecUseLoad =
+                    PartLoadRat * heatCoil.MSParasiticElecLoad(StageNumHS) + (1.0 - PartLoadRat) * heatCoil.MSParasiticElecLoad(StageNumLS);
 
-                state.dataHVACGlobal->ElecHeatingCoilPower = heatingCoil.ElecUseLoad;
-                heatingCoil.HeatingCoilLoad = MSHPMassFlowRateHigh * (HSFullLoadOutAirEnth - InletAirEnthalpy) * PartLoadRat +
+                state.dataHVACGlobal->ElecHeatingCoilPower = heatCoil.ElecUseLoad;
+                heatCoil.HeatingCoilLoad = MSHPMassFlowRateHigh * (HSFullLoadOutAirEnth - InletAirEnthalpy) * PartLoadRat +
                                               MSHPMassFlowRateLow * (LSFullLoadOutAirEnth - InletAirEnthalpy) * (1.0 - PartLoadRat);
                 EffAvg = (EffHS * PartLoadRat) + (EffLS * (1.0 - PartLoadRat));
-                heatingCoil.FuelUseLoad = heatingCoil.HeatingCoilLoad / EffAvg;
-                heatingCoil.ParasiticFuelRate = 0.0;
+                heatCoil.FuelUseLoad = heatCoil.HeatingCoilLoad / EffAvg;
+                heatCoil.ParasiticFuelRate = 0.0;
 
-                OutletAirEnthalpy = InletAirEnthalpy + heatingCoil.HeatingCoilLoad / heatingCoil.InletAirMassFlowRate;
+                OutletAirEnthalpy = InletAirEnthalpy + heatCoil.HeatingCoilLoad / heatCoil.InletAirMassFlowRate;
                 OutletAirTemp = Psychrometrics::PsyTdbFnHW(OutletAirEnthalpy, OutletAirHumRat);
                 FullLoadOutAirRH = Psychrometrics::PsyRhFnTdbWPb(state, OutletAirTemp, OutletAirHumRat, OutdoorPressure, RoutineNameAverageLoad);
 
@@ -2403,10 +2351,10 @@ namespace HeatingCoils {
                     OutletAirHumRat = Psychrometrics::PsyWFnTdbH(state, OutletAirTemp, OutletAirEnthalpy, RoutineName);
                 }
 
-                heatingCoil.OutletAirTemp = OutletAirTemp;
-                heatingCoil.OutletAirHumRat = OutletAirHumRat;
-                heatingCoil.OutletAirEnthalpy = OutletAirEnthalpy;
-                heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+                heatCoil.OutletAirTemp = OutletAirTemp;
+                heatCoil.OutletAirHumRat = OutletAirHumRat;
+                heatCoil.OutletAirEnthalpy = OutletAirEnthalpy;
+                heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
 
                 // Stage 1
             } else if (CycRatio > 0.0) {
@@ -2417,10 +2365,10 @@ namespace HeatingCoils {
                 else if (fanOp == HVAC::FanOp::Continuous)
                     AirMassFlow = MSHPMassFlowRateLow;
 
-                TotCap = heatingCoil.MSNominalCapacity(StageNumLS);
+                TotCap = heatCoil.MSNominalCapacity(StageNumLS);
 
                 PartLoadRat = min(1.0, CycRatio);
-                heatingCoil.RTF = PartLoadRat;
+                heatCoil.RTF = PartLoadRat;
 
                 // Calculate full load outlet conditions
                 FullLoadOutAirEnth = InletAirEnthalpy + TotCap / AirMassFlow;
@@ -2443,42 +2391,42 @@ namespace HeatingCoils {
                     OutletAirTemp = FullLoadOutAirTemp;
                 } else {
                     OutletAirEnthalpy =
-                        PartLoadRat * AirMassFlow / heatingCoil.InletAirMassFlowRate * (FullLoadOutAirEnth - InletAirEnthalpy) + InletAirEnthalpy;
+                        PartLoadRat * AirMassFlow / heatCoil.InletAirMassFlowRate * (FullLoadOutAirEnth - InletAirEnthalpy) + InletAirEnthalpy;
                     OutletAirHumRat =
-                        PartLoadRat * AirMassFlow / heatingCoil.InletAirMassFlowRate * (FullLoadOutAirHumRat - InletAirHumRat) + InletAirHumRat;
+                        PartLoadRat * AirMassFlow / heatCoil.InletAirMassFlowRate * (FullLoadOutAirHumRat - InletAirHumRat) + InletAirHumRat;
                     OutletAirTemp = Psychrometrics::PsyTdbFnHW(OutletAirEnthalpy, OutletAirHumRat);
                 }
 
-                EffLS = heatingCoil.MSEfficiency(StageNumLS);
+                EffLS = heatCoil.MSEfficiency(StageNumLS);
 
-                heatingCoil.HeatingCoilLoad = TotCap * PartLoadRat;
+                heatCoil.HeatingCoilLoad = TotCap * PartLoadRat;
 
-                heatingCoil.FuelUseLoad = heatingCoil.HeatingCoilLoad / EffLS;
+                heatCoil.FuelUseLoad = heatCoil.HeatingCoilLoad / EffLS;
                 //   parasitics are calculated when the coil is off (1-PLR)
-                heatingCoil.ElecUseLoad = heatingCoil.MSParasiticElecLoad(StageNumLS) * (1.0 - PartLoadRat);
-                heatingCoil.ParasiticFuelRate = heatingCoil.ParasiticFuelCapacity * (1.0 - PartLoadRat);
-                state.dataHVACGlobal->ElecHeatingCoilPower = heatingCoil.ElecUseLoad;
-
-                heatingCoil.OutletAirTemp = OutletAirTemp;
-                heatingCoil.OutletAirHumRat = OutletAirHumRat;
-                heatingCoil.OutletAirEnthalpy = OutletAirEnthalpy;
-                heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+                heatCoil.ElecUseLoad = heatCoil.MSParasiticElecLoad(StageNumLS) * (1.0 - PartLoadRat);
+                heatCoil.ParasiticFuelRate = heatCoil.ParasiticFuelCapacity * (1.0 - PartLoadRat);
+                state.dataHVACGlobal->ElecHeatingCoilPower = heatCoil.ElecUseLoad;
+
+                heatCoil.OutletAirTemp = OutletAirTemp;
+                heatCoil.OutletAirHumRat = OutletAirHumRat;
+                heatCoil.OutletAirEnthalpy = OutletAirEnthalpy;
+                heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
             }
 
             // This requires a CR to correct (i.e., calculate outputs when coil is off)
         } else {
 
             // Gas coil is off; just pass through conditions
-            heatingCoil.OutletAirEnthalpy = heatingCoil.InletAirEnthalpy;
-            heatingCoil.OutletAirHumRat = heatingCoil.InletAirHumRat;
-            heatingCoil.OutletAirTemp = heatingCoil.InletAirTemp;
-            heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+            heatCoil.OutletAirEnthalpy = heatCoil.InletAirEnthalpy;
+            heatCoil.OutletAirHumRat = heatCoil.InletAirHumRat;
+            heatCoil.OutletAirTemp = heatCoil.InletAirTemp;
+            heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
 
             // some of these are reset in Init, can be removed to speed up code
-            heatingCoil.ElecUseLoad = 0.0;
-            heatingCoil.HeatingCoilLoad = 0.0;
-            heatingCoil.FuelUseLoad = 0.0;
-            heatingCoil.ParasiticFuelRate = heatingCoil.ParasiticFuelCapacity;
+            heatCoil.ElecUseLoad = 0.0;
+            heatCoil.HeatingCoilLoad = 0.0;
+            heatCoil.FuelUseLoad = 0.0;
+            heatCoil.ParasiticFuelRate = heatCoil.ParasiticFuelCapacity;
             state.dataHVACGlobal->ElecHeatingCoilPower = 0.0;
             PartLoadRat = 0.0;
 
@@ -2486,54 +2434,54 @@ namespace HeatingCoils {
 
         // If the PLF curve is defined the gas usage needs to be modified.
         // The PLF curve is only used when the coil cycles.
-        if (heatingCoil.PLFCurveIndex > 0) {
+        if (heatCoil.PLFCurveIndex > 0) {
             if (PartLoadRat > 0.0 && StageNum < 2) {
-                PLF = Curve::CurveValue(state, heatingCoil.PLFCurveIndex, PartLoadRat);
+                PLF = Curve::CurveValue(state, heatCoil.PLFCurveIndex, PartLoadRat);
                 if (PLF < 0.7) {
-                    if (heatingCoil.PLFErrorCount < 1) {
-                        ++heatingCoil.PLFErrorCount;
+                    if (heatCoil.PLFErrorCount < 1) {
+                        ++heatCoil.PLFErrorCount;
                         ShowWarningError(state,
                                          format("CalcFuelHeatingCoil: {}=\"{}\", PLF curve values",
-                                                HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                                heatingCoil.Name));
+                                                HVAC::coilTypeNames[(int)heatCoil.coilType],
+                                                heatCoil.Name));
                         ShowContinueError(state, format("The PLF curve value = {:.5T} for part-load ratio = {:.5T}", PLF, PartLoadRat));
                         ShowContinueError(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and the simulation continues...");
                         ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:Fuel].");
                     } else {
                         ShowRecurringWarningErrorAtEnd(state,
-                                                       format("{}, Heating coil PLF curve < 0.7 warning continues... ", heatingCoil.Name),
-                                                       heatingCoil.PLFErrorIndex,
+                                                       format("{}, Heating coil PLF curve < 0.7 warning continues... ", heatCoil.Name),
+                                                       heatCoil.PLFErrorIndex,
                                                        PLF,
                                                        PLF);
                     }
                     PLF = 0.7;
                 }
                 // Modify the Gas Coil Consumption and parasitic loads based on PLF curve
-                heatingCoil.RTF = PartLoadRat / PLF;
-                if (heatingCoil.RTF > 1.0 && std::abs(heatingCoil.RTF - 1.0) > 0.001) {
-                    if (heatingCoil.RTFErrorCount < 1) {
-                        ++heatingCoil.RTFErrorCount;
+                heatCoil.RTF = PartLoadRat / PLF;
+                if (heatCoil.RTF > 1.0 && std::abs(heatCoil.RTF - 1.0) > 0.001) {
+                    if (heatCoil.RTFErrorCount < 1) {
+                        ++heatCoil.RTFErrorCount;
                         ShowWarningError(state,
                                          format("CalcFuelHeatingCoil: {}=\"{}\", runtime fraction",
-                                                HVAC::cAllCoilTypes(heatingCoil.HCoilType_Num),
-                                                heatingCoil.Name));
-                        ShowContinueError(state, format("The runtime fraction exceeded 1.0. [{:.4T}].", heatingCoil.RTF));
+                                                HVAC::coilTypeNames[(int)heatCoil.coilType],
+                                                heatCoil.Name));
+                        ShowContinueError(state, format("The runtime fraction exceeded 1.0. [{:.4T}].", heatCoil.RTF));
                         ShowContinueError(state, "Runtime fraction is set to 1.0 and the simulation continues...");
                         ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:Fuel].");
                     } else {
                         ShowRecurringWarningErrorAtEnd(state,
-                                                       format("{}, Heating coil runtime fraction > 1.0 warning continues... ", heatingCoil.Name),
-                                                       heatingCoil.RTFErrorIndex,
-                                                       heatingCoil.RTF,
-                                                       heatingCoil.RTF);
+                                                       format("{}, Heating coil runtime fraction > 1.0 warning continues... ", heatCoil.Name),
+                                                       heatCoil.RTFErrorIndex,
+                                                       heatCoil.RTF,
+                                                       heatCoil.RTF);
                     }
-                    heatingCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
-                } else if (heatingCoil.RTF > 1.0) {
-                    heatingCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
+                    heatCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
+                } else if (heatCoil.RTF > 1.0) {
+                    heatCoil.RTF = 1.0; // Reset coil runtime fraction to 1.0
                 }
-                heatingCoil.ElecUseLoad = heatingCoil.MSParasiticElecLoad(StageNum) * heatingCoil.RTF;
-                heatingCoil.FuelUseLoad = (heatingCoil.MSNominalCapacity(StageNum) / EffLS) * heatingCoil.RTF;
-                heatingCoil.ParasiticFuelRate = heatingCoil.ParasiticFuelCapacity * (1.0 - heatingCoil.RTF);
+                heatCoil.ElecUseLoad = heatCoil.MSParasiticElecLoad(StageNum) * heatCoil.RTF;
+                heatCoil.FuelUseLoad = (heatCoil.MSNominalCapacity(StageNum) / EffLS) * heatCoil.RTF;
+                heatCoil.ParasiticFuelRate = heatCoil.ParasiticFuelCapacity * (1.0 - heatCoil.RTF);
                 // Fan power will also be modified by the heating coil's part load fraction
                 // OnOffFanPartLoadFraction passed to fan via DataHVACGlobals (cycling fan only)
                 if (fanOp == HVAC::FanOp::Cycling) {
@@ -2543,7 +2491,7 @@ namespace HeatingCoils {
         }
 
         // set outlet node temp so parent objects can call calc directly without have to simulate entire model
-        state.dataLoopNodes->Node(heatingCoil.AirOutletNodeNum).Temp = heatingCoil.OutletAirTemp;
+        state.dataLoopNodes->Node(heatCoil.AirOutletNodeNum).Temp = heatCoil.OutletAirTemp;
     }
 
     void CalcDesuperheaterHeatingCoil(EnergyPlusData &state,
@@ -2575,107 +2523,110 @@ namespace HeatingCoils {
         Real64 TempAirOut;      // temperature of the air leaving the desuperheater heating coil [C]
         Real64 HeatingCoilLoad; // actual load delivered by the desuperheater heating coil [W]
         Real64 QCoilCap;        // available capacity of the desuperheater heating coil [W]
-        int SourceID;           // waste heat source id number
 
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+        auto &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
 
-        Real64 Effic = heatingCoil.Efficiency;
-        Real64 AirMassFlow = heatingCoil.InletAirMassFlowRate;
-        Real64 TempAirIn = heatingCoil.InletAirTemp;
-        Real64 Win = heatingCoil.InletAirHumRat;
+        Real64 Effic = heatCoil.Efficiency;
+        Real64 AirMassFlow = heatCoil.InletAirMassFlowRate;
+        Real64 TempAirIn = heatCoil.InletAirTemp;
+        Real64 Win = heatCoil.InletAirHumRat;
         Real64 CapacitanceAir = Psychrometrics::PsyCpAirFnW(Win) * AirMassFlow;
-        Real64 TempSetPoint = heatingCoil.DesiredOutletTemp;
+        Real64 TempSetPoint = heatCoil.DesiredOutletTemp;
 
         // If there is a fault of coil SAT Sensor
-        if (heatingCoil.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
+        if (heatCoil.FaultyCoilSATFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) &&
             (!state.dataGlobal->KickOffSimulation)) {
             // calculate the sensor offset using fault information
-            int FaultIndex = heatingCoil.FaultyCoilSATIndex;
-            heatingCoil.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
+            int FaultIndex = heatCoil.FaultyCoilSATIndex;
+            heatCoil.FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
             // update the TempSetPoint
-            TempSetPoint -= heatingCoil.FaultyCoilSATOffset;
+            TempSetPoint -= heatCoil.FaultyCoilSATOffset;
         }
 
         // Access the appropriate structure to find the available heating capacity of the desuperheater heating coil
         // The nominal capacity of the desuperheater heating coil varies based on the amount of heat rejected by the source
         // Stovall 2011, add comparison to available temperature of heat reclaim source
         if (state.dataHeatingCoils->ValidSourceType(CoilNum)) {
-            SourceID = heatingCoil.ReclaimHeatingSourceIndexNum;
-            switch (heatingCoil.ReclaimHeatingSource) {
-            case HeatObjTypes::COMPRESSORRACK_REFRIGERATEDCASE:
+            switch (heatCoil.ReclaimHeatSourceType) {
+            case HVAC::HeatReclaimType::RefrigeratedCaseCompressorRack: {
                 // Added last term to available energy equations to avoid double counting reclaimed energy
                 // because refrigeration systems are solved outside the hvac time step iterations
-                heatingCoil.RTF = 1.0;
-                heatingCoil.NominalCapacity = state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).AvailCapacity * Effic -
-                                              state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal;
-                break;
-            case HeatObjTypes::CONDENSER_REFRIGERATION:
-                AvailTemp = state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).AvailTemperature;
-                heatingCoil.RTF = 1.0;
+                heatCoil.RTF = 1.0;
+                auto const &reclaimHeat = state.dataHeatBal->HeatReclaimRefrigeratedRack(heatCoil.ReclaimHeatSourceNum);
+                heatCoil.NominalCapacity = reclaimHeat.AvailCapacity * Effic - reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal;
+            } break;
+
+            case HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled:
+            case HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled:
+            case HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled: {
+                auto const &reclaimHeat = state.dataHeatBal->HeatReclaimRefrigCondenser(heatCoil.ReclaimHeatSourceNum);
+                AvailTemp = reclaimHeat.AvailTemperature;
+                heatCoil.RTF = 1.0;
                 if (AvailTemp <= TempAirIn) {
-                    heatingCoil.NominalCapacity = 0.0;
+                    heatCoil.NominalCapacity = 0.0;
                     ShowRecurringWarningErrorAtEnd(
                         state,
-                        format("Coil:Heating:Desuperheater {} - Waste heat source temperature was too low to be useful.", heatingCoil.Name),
-                        heatingCoil.InsuffTemperatureWarn);
+                        format("Coil:Heating:Desuperheater {} - Waste heat source temperature was too low to be useful.", heatCoil.Name),
+                        heatCoil.InsuffTemperatureWarn);
                 } else {
-                    heatingCoil.NominalCapacity = state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).AvailCapacity * Effic -
-                                                  state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal;
+                    heatCoil.NominalCapacity = reclaimHeat.AvailCapacity * Effic - reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal;
                 }
-                break;
-            case HeatObjTypes::COIL_DX_COOLING:
-            case HeatObjTypes::COIL_DX_MULTISPEED:
-            case HeatObjTypes::COIL_DX_MULTIMODE:
-                heatingCoil.RTF = state.dataDXCoils->DXCoil(SourceID).CoolingCoilRuntimeFraction;
-                heatingCoil.NominalCapacity = state.dataHeatBal->HeatReclaimDXCoil(SourceID).AvailCapacity * Effic -
-                                              state.dataHeatBal->HeatReclaimDXCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal;
-                break;
-            case HeatObjTypes::COIL_DX_VARIABLE_COOLING:
+            } break;
+                
+            case HVAC::HeatReclaimType::CoilCoolDXSingleSpeed:
+            case HVAC::HeatReclaimType::CoilCoolDXMultiSpeed:
+            case HVAC::HeatReclaimType::CoilCoolDXMultiMode: {
+                auto const &dxCoil = state.dataDXCoils->DXCoil(heatCoil.ReclaimHeatSourceNum);
+                auto const &reclaimHeat = state.dataHeatBal->HeatReclaimDXCoil(heatCoil.ReclaimHeatSourceNum);
+                heatCoil.RTF = dxCoil.CoolingCoilRuntimeFraction;
+                heatCoil.NominalCapacity = reclaimHeat.AvailCapacity * Effic - reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal;
+            } break;
+              
+            case HVAC::HeatReclaimType::CoilCoolDXVariableSpeed: {
                 // condenser heat rejection
-                heatingCoil.RTF = state.dataVariableSpeedCoils->VarSpeedCoil(SourceID).RunFrac;
-                heatingCoil.NominalCapacity = state.dataHeatBal->HeatReclaimVS_Coil(SourceID).AvailCapacity * Effic -
-                                              state.dataHeatBal->HeatReclaimVS_Coil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal;
-                break;
-            case HeatObjTypes::COIL_COOLING_DX_NEW:
-                // get RTF and NominalCapacity from Coil:CoolingDX
-                {
-                    auto const &thisCoolingCoil = state.dataCoilCoolingDX->coilCoolingDXs[SourceID];
-                    heatingCoil.RTF = thisCoolingCoil.runTimeFraction;
-                    heatingCoil.NominalCapacity =
-                        thisCoolingCoil.reclaimHeat.AvailCapacity * Effic - thisCoolingCoil.reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal;
-                }
-                break;
+                auto const &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(heatCoil.ReclaimHeatSourceNum);
+                auto const &reclaimHeat = state.dataHeatBal->HeatReclaimVS_Coil(heatCoil.ReclaimHeatSourceNum);
+                heatCoil.RTF = vsCoil.RunFrac;
+                heatCoil.NominalCapacity = reclaimHeat.AvailCapacity * Effic - reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal;
+            } break;
+              
+            case HVAC::HeatReclaimType::CoilCoolDX: {
+                auto const &dxCoil = state.dataCoilCoolingDX->coilCoolingDXs[heatCoil.ReclaimHeatSourceNum];
+                heatCoil.RTF = dxCoil.runTimeFraction;
+                heatCoil.NominalCapacity = dxCoil.reclaimHeat.AvailCapacity * Effic - dxCoil.reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal;
+            } break;
+              
             default:
                 assert(false);
             }
 
         } else {
-            heatingCoil.NominalCapacity = 0.0;
+            heatCoil.NominalCapacity = 0.0;
         }
 
         // Control output to meet load (QCoilReq)
-        if ((AirMassFlow > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) && (QCoilReq > 0.0)) {
+        if ((AirMassFlow > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) && (QCoilReq > 0.0)) {
 
             // check to see if the Required heating capacity is greater than the available heating capacity.
-            if (QCoilReq > heatingCoil.NominalCapacity) {
-                QCoilCap = heatingCoil.NominalCapacity;
+            if (QCoilReq > heatCoil.NominalCapacity) {
+                QCoilCap = heatCoil.NominalCapacity;
             } else {
                 QCoilCap = QCoilReq;
             }
 
             // report the runtime fraction of the desuperheater heating coil
-            if (heatingCoil.NominalCapacity > 0.0) {
-                heatingCoil.RTF *= (QCoilCap / heatingCoil.NominalCapacity);
+            if (heatCoil.NominalCapacity > 0.0) {
+                heatCoil.RTF *= (QCoilCap / heatCoil.NominalCapacity);
                 TempAirOut = TempAirIn + QCoilCap / CapacitanceAir;
                 HeatingCoilLoad = QCoilCap;
             } else {
-                heatingCoil.RTF = 0.0;
+                heatCoil.RTF = 0.0;
                 TempAirOut = TempAirIn;
                 HeatingCoilLoad = 0.0;
             }
 
             // Control coil output to meet a setpoint temperature.
-        } else if ((AirMassFlow > 0.0 && heatingCoil.NominalCapacity > 0.0) && (heatingCoil.availSched->getCurrentVal() > 0.0) &&
+        } else if ((AirMassFlow > 0.0 && heatCoil.NominalCapacity > 0.0) && (heatCoil.availSched->getCurrentVal() > 0.0) &&
                    (QCoilReq == DataLoopNode::SensedLoadFlagValue) && (std::abs(TempSetPoint - TempAirIn) > HVAC::TempControlTol)) {
 
             QCoilCap = CapacitanceAir * (TempSetPoint - TempAirIn);
@@ -2684,8 +2635,8 @@ namespace HeatingCoils {
                 QCoilCap = 0.0;
                 TempAirOut = TempAirIn;
                 // check to see if the required heating capacity is greater than the available capacity.
-            } else if (QCoilCap > heatingCoil.NominalCapacity) {
-                QCoilCap = heatingCoil.NominalCapacity;
+            } else if (QCoilCap > heatCoil.NominalCapacity) {
+                QCoilCap = heatCoil.NominalCapacity;
                 TempAirOut = TempAirIn + QCoilCap / CapacitanceAir;
             } else {
                 TempAirOut = TempSetPoint;
@@ -2693,63 +2644,78 @@ namespace HeatingCoils {
 
             HeatingCoilLoad = QCoilCap;
             //     report the runtime fraction of the desuperheater heating coil
-            heatingCoil.RTF *= (QCoilCap / heatingCoil.NominalCapacity);
+            heatCoil.RTF *= (QCoilCap / heatCoil.NominalCapacity);
 
         } else { // If not running, conditions do not change across heating coil from inlet to outlet
 
             TempAirOut = TempAirIn;
             HeatingCoilLoad = 0.0;
-            heatingCoil.ElecUseLoad = 0.0;
-            heatingCoil.RTF = 0.0;
+            heatCoil.ElecUseLoad = 0.0;
+            heatCoil.RTF = 0.0;
         }
 
         // Set the outlet conditions
-        heatingCoil.HeatingCoilLoad = HeatingCoilLoad;
-        heatingCoil.OutletAirTemp = TempAirOut;
+        heatCoil.HeatingCoilLoad = HeatingCoilLoad;
+        heatCoil.OutletAirTemp = TempAirOut;
 
         // This HeatingCoil does not change the moisture or Mass Flow across the component
-        heatingCoil.OutletAirHumRat = heatingCoil.InletAirHumRat;
-        heatingCoil.OutletAirMassFlowRate = heatingCoil.InletAirMassFlowRate;
+        heatCoil.OutletAirHumRat = heatCoil.InletAirHumRat;
+        heatCoil.OutletAirMassFlowRate = heatCoil.InletAirMassFlowRate;
         // Set the outlet enthalpy
-        heatingCoil.OutletAirEnthalpy = Psychrometrics::PsyHFnTdbW(heatingCoil.OutletAirTemp, heatingCoil.OutletAirHumRat);
+        heatCoil.OutletAirEnthalpy = Psychrometrics::PsyHFnTdbW(heatCoil.OutletAirTemp, heatCoil.OutletAirHumRat);
 
-        heatingCoil.ElecUseLoad = heatingCoil.ParasiticElecLoad * heatingCoil.RTF;
+        heatCoil.ElecUseLoad = heatCoil.ParasiticElecLoad * heatCoil.RTF;
         QCoilActual = HeatingCoilLoad;
 
         // Update remaining waste heat (just in case multiple users of waste heat use same source)
         if (state.dataHeatingCoils->ValidSourceType(CoilNum)) {
-            SourceID = heatingCoil.ReclaimHeatingSourceIndexNum;
             //   Refrigerated cases are simulated at the zone time step, do not decrement available capacity
             //   (the heat reclaim available capacity will not get reinitialized as the air loop iterates)
             int DesuperheaterNum = CoilNum - state.dataHeatingCoils->NumElecCoil - state.dataHeatingCoils->NumElecCoilMultiStage -
                                    state.dataHeatingCoils->NumFuelCoil - state.dataHeatingCoils->NumGasCoilMultiStage;
-            switch (heatingCoil.ReclaimHeatingSource) {
-            case HeatObjTypes::COMPRESSORRACK_REFRIGERATEDCASE: {
-                state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
-                state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).HVACDesuperheaterReclaimedHeatTotal = 0.0;
-                for (auto const &num : state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).HVACDesuperheaterReclaimedHeat)
-                    state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).HVACDesuperheaterReclaimedHeatTotal += num;
+
+            switch (heatCoil.ReclaimHeatSourceType) {
+
+            case HVAC::HeatReclaimType::RefrigeratedCaseCompressorRack: {
+                auto &reclaimHeat = state.dataHeatBal->HeatReclaimRefrigeratedRack(heatCoil.ReclaimHeatSourceNum);
+                reclaimHeat.HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
+                reclaimHeat.HVACDesuperheaterReclaimedHeatTotal = 0.0;
+                for (Real64 num : reclaimHeat.HVACDesuperheaterReclaimedHeat)
+                    reclaimHeat.HVACDesuperheaterReclaimedHeatTotal += num;
             } break;
-            case HeatObjTypes::CONDENSER_REFRIGERATION: {
-                state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
-                state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).HVACDesuperheaterReclaimedHeatTotal = 0.0;
-                for (auto const &num : state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).HVACDesuperheaterReclaimedHeat)
-                    state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).HVACDesuperheaterReclaimedHeatTotal += num;
+              
+            case HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled:
+            case HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled:
+            case HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled: {
+                auto &reclaimHeat = state.dataHeatBal->HeatReclaimRefrigCondenser(heatCoil.ReclaimHeatSourceNum);
+                reclaimHeat.HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
+                reclaimHeat.HVACDesuperheaterReclaimedHeatTotal = 0.0;
+                for (Real64 num : reclaimHeat.HVACDesuperheaterReclaimedHeat)
+                    reclaimHeat.HVACDesuperheaterReclaimedHeatTotal += num;
             } break;
-            case HeatObjTypes::COIL_DX_COOLING:
-            case HeatObjTypes::COIL_DX_MULTISPEED:
-            case HeatObjTypes::COIL_DX_MULTIMODE: {
-                state.dataHeatBal->HeatReclaimDXCoil(SourceID).HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
-                state.dataHeatBal->HeatReclaimDXCoil(SourceID).HVACDesuperheaterReclaimedHeatTotal = 0.0;
-                for (auto const &num : state.dataHeatBal->HeatReclaimDXCoil(SourceID).HVACDesuperheaterReclaimedHeat)
-                    state.dataHeatBal->HeatReclaimDXCoil(SourceID).HVACDesuperheaterReclaimedHeatTotal += num;
+              
+            case HVAC::HeatReclaimType::CoilCoolDXSingleSpeed:
+            case HVAC::HeatReclaimType::CoilCoolDXMultiSpeed:
+            case HVAC::HeatReclaimType::CoilCoolDXMultiMode: {
+                auto &reclaimHeat = state.dataHeatBal->HeatReclaimDXCoil(heatCoil.ReclaimHeatSourceNum);
+                reclaimHeat.HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
+                reclaimHeat.HVACDesuperheaterReclaimedHeatTotal = 0.0;
+                for (Real64 num : reclaimHeat.HVACDesuperheaterReclaimedHeat)
+                    reclaimHeat.HVACDesuperheaterReclaimedHeatTotal += num;
             } break;
-            case HeatObjTypes::COIL_DX_VARIABLE_COOLING: {
-                state.dataHeatBal->HeatReclaimVS_Coil(SourceID).HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
-                state.dataHeatBal->HeatReclaimVS_Coil(SourceID).HVACDesuperheaterReclaimedHeatTotal = 0.0;
-                for (auto const &num : state.dataHeatBal->HeatReclaimVS_Coil(SourceID).HVACDesuperheaterReclaimedHeat)
-                    state.dataHeatBal->HeatReclaimVS_Coil(SourceID).HVACDesuperheaterReclaimedHeatTotal += num;
+              
+            case HVAC::HeatReclaimType::CoilCoolDXVariableSpeed: {
+                auto &reclaimHeat = state.dataHeatBal->HeatReclaimVS_Coil(heatCoil.ReclaimHeatSourceNum);
+                reclaimHeat.HVACDesuperheaterReclaimedHeat(DesuperheaterNum) = HeatingCoilLoad;
+                reclaimHeat.HVACDesuperheaterReclaimedHeatTotal = 0.0;
+                for (Real64 num : reclaimHeat.HVACDesuperheaterReclaimedHeat)
+                    reclaimHeat.HVACDesuperheaterReclaimedHeatTotal += num;
             } break;
+
+            case HVAC::HeatReclaimType::CoilCoolDX: {
+                // What about this guy?
+            } break;
+              
             default:
                 break;
             }
@@ -2769,15 +2735,15 @@ namespace HeatingCoils {
         // Data is moved from the coil data structure to the coil outlet nodes.
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        auto const &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
-        auto const &airInletNode = state.dataLoopNodes->Node(heatingCoil.AirInletNodeNum);
-        auto &airOuletNode = state.dataLoopNodes->Node(heatingCoil.AirOutletNodeNum);
+        auto const &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+        auto const &airInletNode = state.dataLoopNodes->Node(heatCoil.AirInletNodeNum);
+        auto &airOuletNode = state.dataLoopNodes->Node(heatCoil.AirOutletNodeNum);
 
         // Set the outlet air nodes of the HeatingCoil
-        airOuletNode.MassFlowRate = heatingCoil.OutletAirMassFlowRate;
-        airOuletNode.Temp = heatingCoil.OutletAirTemp;
-        airOuletNode.HumRat = heatingCoil.OutletAirHumRat;
-        airOuletNode.Enthalpy = heatingCoil.OutletAirEnthalpy;
+        airOuletNode.MassFlowRate = heatCoil.OutletAirMassFlowRate;
+        airOuletNode.Temp = heatCoil.OutletAirTemp;
+        airOuletNode.HumRat = heatCoil.OutletAirHumRat;
+        airOuletNode.Enthalpy = heatCoil.OutletAirEnthalpy;
 
         // Set the outlet nodes for properties that just pass through & not used
         airOuletNode.Quality = airInletNode.Quality;
@@ -2808,65 +2774,48 @@ namespace HeatingCoils {
 
         // Using/Aliasing
         Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
+
+        auto &heatCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
 
         // report the HeatingCoil energy from this component
-        heatingCoil.HeatingCoilRate = heatingCoil.HeatingCoilLoad;
-        heatingCoil.HeatingCoilLoad *= TimeStepSysSec;
+        heatCoil.HeatingCoilRate = heatCoil.HeatingCoilLoad;
+        heatCoil.HeatingCoilLoad *= TimeStepSysSec;
 
-        heatingCoil.FuelUseRate = heatingCoil.FuelUseLoad;
-        heatingCoil.ElecUseRate = heatingCoil.ElecUseLoad;
+        heatCoil.FuelUseRate = heatCoil.FuelUseLoad;
+        heatCoil.ElecUseRate = heatCoil.ElecUseLoad;
         if (coilIsSuppHeater) {
-            state.dataHVACGlobal->SuppHeatingCoilPower = heatingCoil.ElecUseLoad;
+            state.dataHVACGlobal->SuppHeatingCoilPower = heatCoil.ElecUseLoad;
         } else {
-            state.dataHVACGlobal->ElecHeatingCoilPower = heatingCoil.ElecUseLoad;
+            state.dataHVACGlobal->ElecHeatingCoilPower = heatCoil.ElecUseLoad;
         }
-        heatingCoil.FuelUseLoad *= TimeStepSysSec;
-        heatingCoil.ElecUseLoad *= TimeStepSysSec;
+        heatCoil.FuelUseLoad *= TimeStepSysSec;
+        heatCoil.ElecUseLoad *= TimeStepSysSec;
 
-        heatingCoil.ParasiticFuelConsumption = heatingCoil.ParasiticFuelRate * TimeStepSysSec;
+        heatCoil.ParasiticFuelConsumption = heatCoil.ParasiticFuelRate * TimeStepSysSec;
 
-        std::string coilObjClassName;
-        switch (heatingCoil.HCoilType_Num) {
-        case HVAC::Coil_HeatingElectric: {
-            coilObjClassName = "Coil:Heating:Electric";
-        } break;
-        case HVAC::Coil_HeatingElectric_MultiStage: {
-            coilObjClassName = "Coil:Heating:Electric:MultiStage";
-        } break;
-        case HVAC::Coil_HeatingGasOrOtherFuel: {
-            coilObjClassName = "Coil:Heating:Fuel";
-        } break;
-        case HVAC::Coil_HeatingGas_MultiStage: {
-            coilObjClassName = "Coil:Heating:Gas:MultiStage";
-        } break;
-        case HVAC::Coil_HeatingDesuperheater: {
-            coilObjClassName = "Coil:Heating:Desuperheater";
-        } break;
-        default:
-            break;
-        }
-        if (heatingCoil.reportCoilFinalSizes) {
+        if (heatCoil.reportCoilFinalSizes) {
             if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(
-                    state, heatingCoil.Name, coilObjClassName, heatingCoil.NominalCapacity, heatingCoil.NominalCapacity, -999.0, -999.0);
-                heatingCoil.reportCoilFinalSizes = false;
+                ReportCoilSelection::setCoilFinalSizes(
+                    state, heatCoil.Name, heatCoil.coilType, heatCoil.NominalCapacity, heatCoil.NominalCapacity, -999.0, -999.0);
+                heatCoil.reportCoilFinalSizes = false;
             }
         }
     }
 
-    //        End of Reporting subroutines for the HeatingCoil Module
-
-    void GetCoilIndex(EnergyPlusData &state, std::string const &HeatingCoilName, int &HeatingCoilIndex, bool &ErrorsFound)
+#ifdef OLD_API  
+    int GetCoilIndex(EnergyPlusData &state,
+                   std::string_view const coilType,
+                   std::string const &coilName,
+                   bool &ErrorsFound)
     {
+        // FUNCTION INFORMATION:
+        //       AUTHOR         Richard Raustad, FSEC
+        //       DATE WRITTEN   February 2013
 
-        // SUBROUTINE INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   March 2005
-
-        // PURPOSE OF THIS SUBROUTINE:
-        // This subroutine sets an index for a given DX Coil -- issues error message if that
-        // DX Coil is not a legal DX Coil.
+        // PURPOSE OF THIS FUNCTION:
+        // This function looks up the given coil and returns the availability schedule index.  If
+        // incorrect coil type or name is given, ErrorsFound is returned as true and index is returned
+        // as zero.
 
         // Obtains and Allocates HeatingCoil related parameters from input file
         if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
@@ -2874,13 +2823,38 @@ namespace HeatingCoils {
             state.dataHeatingCoils->GetCoilsInputFlag = false;
         }
 
-        HeatingCoilIndex = Util::FindItem(HeatingCoilName, state.dataHeatingCoils->HeatingCoil);
-        if (HeatingCoilIndex == 0) {
-            ShowSevereError(state, format("GetCoilIndex: Heating coil not found={}", HeatingCoilName));
+        int coilNum = Util::FindItem(coilName, state.dataHeatingCoils->HeatingCoil);
+        if (coilNum == 0) {
+            ShowSevereError(state, format("GetCoilIndex: Could not find Coil, Type=\"{}\" Name=\"{}\"", coilType, coilName));
             ErrorsFound = true;
         }
+
+        return coilNum;
     }
+  
+    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state,
+                                       std::string_view const coilType,
+                                       std::string const &coilName,
+                                       bool &ErrorsFound
+    )
+    {
+        int coilNum = GetCoilIndex(state, coilType, coilName, ErrorsFound);
+        return (coilNum == 0) ? nullptr : state.dataHeatingCoils->HeatingCoil(coilNum).availSched;
+    }
+#endif // OLD_API
+  
+        //        End of Reporting subroutines for the HeatingCoil Module
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName)
+    {
+        // Obtains and Allocates HeatingCoil related parameters from input file
+        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
+            GetHeatingCoilInput(state);
+            state.dataHeatingCoils->GetCoilsInputFlag = false;
+        }
 
+        return Util::FindItem(coilName, state.dataHeatingCoils->HeatingCoil);
+    }
+#ifdef OLD_API  
     void CheckHeatingCoilSchedule(EnergyPlusData &state,
                                   std::string const &CompType, // unused1208
                                   std::string_view CompName,
@@ -2908,12 +2882,12 @@ namespace HeatingCoils {
             if (CoilNum == 0) {
                 ShowFatalError(state, format("CheckHeatingCoilSchedule: Coil not found=\"{}\".", CompName));
             }
-            if (!Util::SameString(CompType, HVAC::cAllCoilTypes(state.dataHeatingCoils->HeatingCoil(CoilNum).HCoilType_Num))) {
+            if (!Util::SameString(CompType, HVAC::coilTypeNames[(int)state.dataHeatingCoils->HeatingCoil(CoilNum).coilType])) {
                 ShowSevereError(state, format("CheckHeatingCoilSchedule: Coil=\"{}\"", CompName));
                 ShowContinueError(state,
                                   format("...expected type=\"{}\", actual type=\"{}\".",
                                          CompType,
-                                         HVAC::cAllCoilTypes(state.dataHeatingCoils->HeatingCoil(CoilNum).HCoilType_Num)));
+                                         HVAC::coilTypeNames[(int)state.dataHeatingCoils->HeatingCoil(CoilNum).coilType]));
                 ShowFatalError(state, "Program terminates due to preceding conditions.");
             }
             CompIndex = CoilNum;
@@ -2936,517 +2910,92 @@ namespace HeatingCoils {
                 ShowContinueError(state,
                                   format("...expected type=\"{}\", actual type=\"{}\".",
                                          CompType,
-                                         HVAC::cAllCoilTypes(state.dataHeatingCoils->HeatingCoil(CoilNum).HCoilType_Num)));
+                                         HVAC::coilTypeNames[(int)state.dataHeatingCoils->HeatingCoil(CoilNum).coilType]));
                 ShowFatalError(state, "Program terminates due to preceding conditions.");
             }
             Value = state.dataHeatingCoils->HeatingCoil(CoilNum).availSched->getCurrentVal(); // not scheduled?
         }
     }
-
-    Real64 GetCoilCapacity(EnergyPlusData &state,
-                           std::string const &CoilType, // must match coil types in this module
-                           std::string const &CoilName, // must match coil names for the coil type
-                           bool &ErrorsFound            // set to true if problem
-    )
+#endif // OLD_API
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   February 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the coil capacity for the given coil and returns it.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
-        // as negative.
-
-        // Return value
-        Real64 CoilCapacity; // returned capacity of matched coil
-
-        // FUNCTION LOCAL VARIABLE DECLARATIONS:
-        int WhichCoil;
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingGasOrOtherFuel ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                CoilCapacity = state.dataHeatingCoils->HeatingCoil(WhichCoil).NominalCapacity;
-            }
-        } else if (FoundType == HVAC::Coil_HeatingElectric_MultiStage || FoundType == HVAC::Coil_HeatingGas_MultiStage) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                CoilCapacity =
-                    state.dataHeatingCoils->HeatingCoil(WhichCoil).MSNominalCapacity(state.dataHeatingCoils->HeatingCoil(WhichCoil).NumOfStages);
-            }
-        } else {
-            WhichCoil = 0;
-        }
-
-        if (WhichCoil == 0) { // Autodesk:Return Reworked block to assure CoilCapacity is set before return
-            if (FoundType == 0) {
-                ShowSevereError(state, format("GetCoilCapacity: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            } else if (FoundType > 0) {
-                ShowSevereError(state, format("GetCoilCapacity: Invalid coil type for capacity, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-                ShowContinueError(state,
-                                  format("...only {}, {} or {} are valid in this context.",
-                                         HVAC::cAllCoilTypes(HVAC::Coil_HeatingElectric),
-                                         HVAC::cAllCoilTypes(HVAC::Coil_HeatingGasOrOtherFuel),
-                                         HVAC::cAllCoilTypes(HVAC::Coil_HeatingDesuperheater)));
-            }
-            ShowContinueError(state, "... returning Coil Capacity as -1000.");
-            ErrorsFound = true;
-            CoilCapacity = -1000.0;
-        }
-
-        return CoilCapacity;
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).availSched->getCurrentVal(); // not scheduled?
     }
 
-    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state,
-                                       std::string const &CoilType, // must match coil types in this module
-                                       std::string const &CoilName, // must match coil names for the coil type
-                                       bool &ErrorsFound            // set to true if problem
-    )
+    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad, FSEC
-        //       DATE WRITTEN   February 2013
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the availability schedule index.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and index is returned
-        // as zero.
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int WhichCoil = 0;
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingElectric_MultiStage ||
-            FoundType == HVAC::Coil_HeatingGasOrOtherFuel || FoundType == HVAC::Coil_HeatingGas_MultiStage ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                return state.dataHeatingCoils->HeatingCoil(WhichCoil).availSched;
-            }
-        } else {
-            WhichCoil = 0;
-        }
-
-        if (WhichCoil == 0) {
-            ShowSevereError(state, format("GetCoilAvailScheduleIndex: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-        }
-
-        return nullptr;
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).availSched;      
     }
-
-    int GetCoilInletNode(EnergyPlusData &state,
-                         std::string_view CoilType,   // must match coil types in this module
-                         std::string const &CoilName, // must match coil names for the coil type
-                         bool &ErrorsFound            // set to true if problem
-    )
+  
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   February 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the inlet node number.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-        // as zero.
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int WhichCoil = 0;
-        int NodeNumber = 0;
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingElectric_MultiStage ||
-            FoundType == HVAC::Coil_HeatingGasOrOtherFuel || FoundType == HVAC::Coil_HeatingGas_MultiStage ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                NodeNumber = state.dataHeatingCoils->HeatingCoil(WhichCoil).AirInletNodeNum;
-            }
-        } else {
-            WhichCoil = 0;
-        }
-
-        if (WhichCoil == 0) {
-            ShowSevereError(state, format("GetCoilInletNode: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            NodeNumber = 0;
-        }
-
-        return NodeNumber;
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).AirInletNodeNum;
     }
 
-    int GetCoilOutletNode(EnergyPlusData &state,
-                          std::string_view CoilType,   // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
-    )
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   August 2006
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the outlet node number.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-        // as zero.
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int WhichCoil = 0;
-        int NodeNumber = 0;
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingElectric_MultiStage ||
-            FoundType == HVAC::Coil_HeatingGasOrOtherFuel || FoundType == HVAC::Coil_HeatingGas_MultiStage ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                NodeNumber = state.dataHeatingCoils->HeatingCoil(WhichCoil).AirOutletNodeNum;
-            }
-        } else {
-            WhichCoil = 0;
-        }
-
-        if (WhichCoil == 0) {
-            ShowSevereError(state, format("GetCoilOutletNode: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            NodeNumber = 0;
-        }
-
-        return NodeNumber;
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).AirOutletNodeNum;
     }
 
-    int GetHeatReclaimSourceIndex(EnergyPlusData &state,
-                                  std::string const &CoilType, // must match coil types in this module
-                                  std::string const &CoilName, // must match coil names for the coil type
+  #ifdef OLD_API
+    int GetCoilReclaimSourceIndex(EnergyPlusData &state,
+                                  std::string_view const coilType, // must match coil types in this module
+                                  std::string const &coilName, // must match coil names for the coil type
                                   bool &ErrorsFound            // set to true if problem
     )
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   June 2007
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the heating coil index number if it is a desuperheating coil.
-        // If incorrect coil type or name is given, ErrorsFound is returned as true and index number is returned
-        // as zero.
-
-        // FUNCTION LOCAL VARIABLE DECLARATIONS:
-        bool GetCoilErrFlag;
-        int NumCoil;
-        int CoilNum(0);
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int CoilFound = 0;
-
-        // note should eventually get rid of this string comparison
-        if (Util::SameString(CoilType, "COIL:COOLING:DX:SINGLESPEED") || Util::SameString(CoilType, "COIL:COOLING:DX:TWOSPEED") ||
-            Util::SameString(CoilType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
-            bool SuppressWarning = true;
-            DXCoils::GetDXCoilIndex(state, CoilName, CoilNum, GetCoilErrFlag, CoilType, SuppressWarning);
-            for (NumCoil = 1; NumCoil <= state.dataHeatingCoils->NumHeatingCoils; ++NumCoil) {
-                if (state.dataHeatingCoils->HeatingCoil(NumCoil).ReclaimHeatingSource != HeatObjTypes::COIL_DX_COOLING &&
-                    state.dataHeatingCoils->HeatingCoil(NumCoil).ReclaimHeatingSource != HeatObjTypes::COIL_DX_MULTISPEED &&
-                    state.dataHeatingCoils->HeatingCoil(NumCoil).ReclaimHeatingSource != HeatObjTypes::COIL_DX_MULTIMODE &&
-                    state.dataHeatingCoils->HeatingCoil(NumCoil).ReclaimHeatingCoilName != CoilName)
-                    continue;
-                CoilFound = CoilNum;
-                break;
-            }
-        } else if (Util::SameString(CoilType, "COIL:COOLING:DX:VARIABLESPEED")) {
-            CoilNum = VariableSpeedCoils::GetCoilIndexVariableSpeed(state, CoilType, CoilName, GetCoilErrFlag);
-            for (NumCoil = 1; NumCoil <= state.dataHeatingCoils->NumHeatingCoils; ++NumCoil) {
-                if (state.dataHeatingCoils->HeatingCoil(NumCoil).ReclaimHeatingSource != HeatObjTypes::COIL_DX_VARIABLE_COOLING &&
-                    state.dataHeatingCoils->HeatingCoil(NumCoil).ReclaimHeatingCoilName != CoilName)
-                    continue;
-                CoilFound = CoilNum;
-                break;
-            }
-        }
-
-        if (CoilNum == 0) {
-            ErrorsFound = true;
-        }
-
-        return CoilFound;
+        int coilNum = GetCoilIndex(state, coilType, coilName, ErrorsFound);
+        return (coilNum == 0) ? 0 : state.dataHeatingCoils->HeatingCoil(coilNum).ReclaimHeatSourceNum;
     }
-
-    int GetCoilControlNodeNum(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    )
+#endif // OLD_API
+  
+    int GetCoilControlNode(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   June 2007
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the control node number.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-        // as zero.
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingElectric_MultiStage ||
-            FoundType == HVAC::Coil_HeatingGasOrOtherFuel || FoundType == HVAC::Coil_HeatingGas_MultiStage ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            int WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                return state.dataHeatingCoils->HeatingCoil(WhichCoil).TempSetPointNodeNum;
-            }
-        }
-
-        ShowSevereError(state, format("GetCoilControlNodeNum: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-        ErrorsFound = true;
-        return 0;
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).TempSetPointNodeNum;
     }
 
-    int GetHeatingCoilTypeNum(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    )
+    int GetCoilPLFCurveIndex(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   August 2008
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the type number.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and type number is returned
-        // as zero.
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingElectric_MultiStage ||
-            FoundType == HVAC::Coil_HeatingGasOrOtherFuel || FoundType == HVAC::Coil_HeatingGas_MultiStage ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            int WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                return state.dataHeatingCoils->HeatingCoil(WhichCoil).HCoilType_Num;
-            }
-        }
-
-        ShowSevereError(state, format("GetHeatingCoilTypeNum: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-        ErrorsFound = true;
-        return 0;
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).PLFCurveIndex;
     }
 
-    int GetHeatingCoilIndex(EnergyPlusData &state,
-                            std::string const &CoilType, // must match coil types in this module
-                            std::string const &CoilName, // must match coil names for the coil type
-                            bool &ErrorsFound            // set to true if problem
-    )
+    int GetCoilNumberOfStages(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Linda Lawrie
-        //       DATE WRITTEN   February 2011
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the index into the structure.  If
-        // incorrect coil type or name is given, ErrorsFound is returned as true and index is returned
-        // as zero.
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int WhichCoil = 0;
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingElectric_MultiStage ||
-            FoundType == HVAC::Coil_HeatingGasOrOtherFuel || FoundType == HVAC::Coil_HeatingGas_MultiStage ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-        }
-
-        if (WhichCoil == 0) {
-            ShowSevereError(state, format("GetHeatingCoilIndex: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-        }
-
-        return WhichCoil;
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).NumOfStages;
     }
 
-    int GetHeatingCoilPLFCurveIndex(EnergyPlusData &state,
-                                    std::string const &CoilType, // must match coil types in this module
-                                    std::string const &CoilName, // must match coil names for the coil type
-                                    bool &ErrorsFound            // set to true if problem
-    )
+    void SetCoilDesicData(EnergyPlusData &state, int const coilNum, bool desicRegenCoil, int desicDehumNum) 
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Richard Raustad
-        //       DATE WRITTEN   December 2008
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the PLF curve index.  If
-        // incorrect coil name is given for gas or electric heating coils, ErrorsFound
-        // is returned as true and curve index is returned as zero.
-        // If not a gas or electric heating coil, ErrorsFound is unchanged and index is 0.
-
-        // Obtains and Allocates HeatingCoil related parameters from input file
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int FoundType = Util::FindItem(CoilType, HVAC::cAllCoilTypes, HVAC::NumAllCoilTypes);
-        if (FoundType == HVAC::Coil_HeatingElectric || FoundType == HVAC::Coil_HeatingElectric_MultiStage ||
-            FoundType == HVAC::Coil_HeatingGasOrOtherFuel || FoundType == HVAC::Coil_HeatingGas_MultiStage ||
-            FoundType == HVAC::Coil_HeatingDesuperheater) {
-            int WhichCoil = Util::FindItem(CoilName, state.dataHeatingCoils->HeatingCoil);
-            if (WhichCoil != 0) {
-                return state.dataHeatingCoils->HeatingCoil(WhichCoil).PLFCurveIndex;
-            } else {
-                ShowSevereError(state, format("GetHeatingCoilPLFCurveIndex: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-                ErrorsFound = true;
-                return 0;
-            }
-        } else {
-            return 0;
-        }
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        state.dataHeatingCoils->HeatingCoil(coilNum).DesiccantRegenerationCoil = desicRegenCoil;
+        state.dataHeatingCoils->HeatingCoil(coilNum).DesiccantDehumNum = desicDehumNum;
     }
 
-    int GetHeatingCoilNumberOfStages(EnergyPlusData &state,
-                                     std::string const &CoilType, // must match coil types in this module
-                                     std::string const &CoilName, // must match coil names for the coil type
-                                     bool &ErrorsFound            // set to true if problem
-    )
+    void SetCoilAirLoopNumber(EnergyPlusData &state, int const coilNum, int AirLoopNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Chandan Sharma
-        //       DATE WRITTEN   February 2013
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function looks up the given coil and returns the number of speeds for multistage coils.
-        // If incorrect coil type or name is given, ErrorsFound is returned as true.
-
-        // Obtains and Allocates HeatingCoils
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        int WhichCoil = Util::FindItemInList(CoilName, state.dataHeatingCoils->HeatingCoil);
-        if (WhichCoil != 0) {
-            return state.dataHeatingCoils->HeatingCoil(WhichCoil).NumOfStages;
-        } else {
-            ShowSevereError(state, format("GetHeatingCoilNumberOfSpeeds: Invalid Heating Coil Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-            ErrorsFound = true;
-            return 0;
-        }
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        state.dataHeatingCoils->HeatingCoil(coilNum).AirLoopNum = AirLoopNum;
     }
 
-    void SetHeatingCoilData(EnergyPlusData &state,
-                            int const CoilNum,                                  // Number of electric or gas heating Coil
-                            bool &ErrorsFound,                                  // Set to true if certain errors found
-                            ObjexxFCL::Optional_bool DesiccantRegenerationCoil, // Flag that this coil is used as regeneration air heating coil
-                            ObjexxFCL::Optional_int DesiccantDehumIndex         // Index for the desiccant dehum system where this coil is used
-    )
+    int GetCoilHeatReclaimSourceIndex(EnergyPlusData &state, int const coilNum)
     {
-
-        // FUNCTION INFORMATION:
-        //       AUTHOR         Bereket Nigusse
-        //       DATE WRITTEN   February 2016
-
-        // PURPOSE OF THIS FUNCTION:
-        // This function sets data to Heating Coil using the coil index and arguments passed
-
-        auto &heatingCoil = state.dataHeatingCoils->HeatingCoil(CoilNum);
-        if (state.dataHeatingCoils->GetCoilsInputFlag) {
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        if (CoilNum <= 0 || CoilNum > state.dataHeatingCoils->NumHeatingCoils) {
-            ShowSevereError(state,
-                            format("SetHeatingCoilData: called with heating coil Number out of range={} should be >0 and <{}",
-                                   CoilNum,
-                                   state.dataHeatingCoils->NumHeatingCoils));
-            ErrorsFound = true;
-            return;
-        }
-
-        if (present(DesiccantRegenerationCoil)) {
-            heatingCoil.DesiccantRegenerationCoil = DesiccantRegenerationCoil;
-        }
-
-        if (present(DesiccantDehumIndex)) {
-            heatingCoil.DesiccantDehumNum = DesiccantDehumIndex;
-        }
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).ReclaimHeatSourceNum;
     }
 
-    void SetHeatingCoilAirLoopNumber(EnergyPlusData &state, std::string const &HeatingCoilName, int AirLoopNum, bool &ErrorsFound)
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum)
     {
-        // SUBROUTINE INFORMATION:
-        //       AUTHOR         L.Gu
-        //       DATE WRITTEN   March 2018
-
-        // PURPOSE OF THIS SUBROUTINE:
-        // This subroutine sets an AirLoopNum for a given heating Coil
-
-        int HeatingCoilIndex;
-
-        if (state.dataHeatingCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetHeatingCoilInput(state);
-            state.dataHeatingCoils->GetCoilsInputFlag = false;
-        }
-
-        HeatingCoilIndex = Util::FindItem(HeatingCoilName, state.dataHeatingCoils->HeatingCoil);
-        if (HeatingCoilIndex == 0) {
-            ShowSevereError(state, format("GetCoilIndex: Heating coil not found={}", HeatingCoilName));
-            ErrorsFound = true;
-        } else {
-            state.dataHeatingCoils->HeatingCoil(HeatingCoilIndex).AirLoopNum = AirLoopNum;
-        }
+        assert(coilNum > 0 && coilNum <= state.dataHeatingCoils->NumHeatingCoils);
+        return state.dataHeatingCoils->HeatingCoil(coilNum).NominalCapacity;
     }
+  
 } // namespace HeatingCoils
 
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/HeatingCoils.hh b/src/EnergyPlus/HeatingCoils.hh
index 2b68e775d8d..a8040e00069 100644
--- a/src/EnergyPlus/HeatingCoils.hh
+++ b/src/EnergyPlus/HeatingCoils.hh
@@ -67,26 +67,12 @@ namespace HeatingCoils {
     // MODULE PARAMETER DEFINITIONS
     Real64 constexpr MinAirMassFlow(0.001);
 
-    enum class HeatObjTypes // reclaim heat object types
-    {
-        Invalid = -1,
-        COMPRESSORRACK_REFRIGERATEDCASE,
-        COIL_DX_COOLING, // single speed DX
-        COIL_DX_MULTISPEED,
-        COIL_DX_MULTIMODE,
-        CONDENSER_REFRIGERATION,
-        COIL_DX_VARIABLE_COOLING,
-        COIL_COOLING_DX_NEW, // Coil:Cooling:DX main one-for-all coil
-        Num
-    };
-
     struct HeatingCoilEquipConditions
     {
         // Members
         std::string Name;             // Name of the HeatingCoil
-        std::string HeatingCoilType;  // Type of HeatingCoil ie. Heating or Cooling
         std::string HeatingCoilModel; // Type of HeatingCoil ie. Simple, Detailed, etc.
-        int HCoilType_Num = 0;
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;
         Constant::eFuel FuelType = Constant::eFuel::Invalid; // Type of fuel used, reference resource type integers
         Sched::Schedule *availSched = nullptr;               // availability schedule
         int InsuffTemperatureWarn = 0;                       // Used for recurring error message
@@ -123,9 +109,11 @@ namespace HeatingCoils {
         int RTFErrorCount = 0;                 // used in recurring error warnings
         int PLFErrorIndex = 0;                 // used in recurring error warnings
         int PLFErrorCount = 0;                 // used in recurring error warnings
-        std::string ReclaimHeatingCoilName;    // Name of reclaim heating coil
-        int ReclaimHeatingSourceIndexNum = 0;  // Index to reclaim heating source (condenser) of a specific type
-        HeatObjTypes ReclaimHeatingSource = HeatObjTypes::Invalid; // The source for the Reclaim Heating Coil
+
+        std::string ReclaimHeatSourceName;    // Name of reclaim heating coil
+        int ReclaimHeatSourceNum = 0;  // Index to reclaim heating source (condenser) of a specific type
+        HVAC::HeatReclaimType ReclaimHeatSourceType = HVAC::HeatReclaimType::Invalid; // The source for the Reclaim Heating Coil
+
         int NumOfStages = 0;                                       // Number of speeds
         Array1D<Real64> MSNominalCapacity;                         // Nominal Capacity MS AC Furnace [W]
         Array1D<Real64> MSEfficiency;                              // Efficiency for MS AC Furnace [dimensionless]
@@ -155,8 +143,21 @@ namespace HeatingCoils {
                                        ObjexxFCL::Optional<Real64 const> PartLoadRatio = _, // part-load ratio of heating coil
                                        ObjexxFCL::Optional_int StageNum = _,
                                        ObjexxFCL::Optional<Real64 const> SpeedRatio = _ // Speed ratio of MultiStage heating coil
-    );
 
+                                       );
+
+    void SimulateHeatingCoilComponents(EnergyPlusData &state,
+                                       int const coilNum,
+                                       bool FirstHVACIteration,
+                                       ObjexxFCL::Optional<Real64 const> QCoilReq = _, // coil load to be met
+                                       ObjexxFCL::Optional<Real64> QCoilActual = _, // coil load actually delivered returned to calling component
+                                       ObjexxFCL::Optional_bool_const SuppHeat = _, // True if current heating coil is a supplemental heating coil
+                                       ObjexxFCL::Optional<HVAC::FanOp const> fanOp = _,    // fan operating mode, FanOp::Cycling or FanOp::Continuous
+                                       ObjexxFCL::Optional<Real64 const> PartLoadRatio = _, // part-load ratio of heating coil
+                                       ObjexxFCL::Optional_int StageNum = _,
+                                       ObjexxFCL::Optional<Real64 const> SpeedRatio = _ // Speed ratio of MultiStage heating coil
+    );
+  
     void GetHeatingCoilInput(EnergyPlusData &state);
 
     void InitHeatingCoil(EnergyPlusData &state, int CoilNum, bool FirstHVACIteration, Real64 QCoilRequired);
@@ -206,84 +207,50 @@ namespace HeatingCoils {
 
     void ReportHeatingCoil(EnergyPlusData &state, int CoilNum, bool coilIsSuppHeater);
 
-    void GetCoilIndex(EnergyPlusData &state, std::string const &HeatingCoilName, int &HeatingCoilIndex, bool &ErrorsFound);
 
-    void CheckHeatingCoilSchedule(EnergyPlusData &state,
-                                  std::string const &CompType, // unused1208
-                                  std::string_view CompName,
-                                  Real64 &Value,
-                                  int &CompIndex);
+    int GetCoilIndex(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
+#ifdef OLD_API
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, std::string_view const compType, std::string const &compName, bool &ErrorsFound);
 
-    Real64 GetCoilCapacity(EnergyPlusData &state,
-                           std::string const &CoilType, // must match coil types in this module
-                           std::string const &CoilName, // must match coil names for the coil type
-                           bool &ErrorsFound            // set to true if problem
-    );
+    Real64 GetCoilCapacity(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state,
-                                       std::string const &CoilType, // must match coil types in this module
-                                       std::string const &CoilName, // must match coil names for the coil type
-                                       bool &ErrorsFound            // set to true if problem
-    );
+    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilInletNode(EnergyPlusData &state,
-                         std::string_view CoilType,   // must match coil types in this module
-                         std::string const &CoilName, // must match coil names for the coil type
-                         bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilAirInletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilOutletNode(EnergyPlusData &state,
-                          std::string_view CoilType,   // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilAirOutletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetHeatReclaimSourceIndex(EnergyPlusData &state,
-                                  std::string const &CoilType, // must match coil types in this module
-                                  std::string const &CoilName, // must match coil names for the coil type
-                                  bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilHeatReclaimSourceIndex(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilControlNodeNum(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilControlNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetHeatingCoilTypeNum(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilPLFCurve(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetHeatingCoilIndex(EnergyPlusData &state,
-                            std::string const &CoilType, // must match coil types in this module
-                            std::string const &CoilName, // must match coil names for the coil type
-                            bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilNumberOfStages(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
+#endif // OLD_API
+  
+    // New API
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
 
-    int GetHeatingCoilPLFCurveIndex(EnergyPlusData &state,
-                                    std::string const &CoilType, // must match coil types in this module
-                                    std::string const &CoilName, // must match coil names for the coil type
-                                    bool &ErrorsFound            // set to true if problem
-    );
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilHeatReclaimSourceIndex(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilControlNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilPLFCurveIndex(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilNumberOfStages(EnergyPlusData &state, int const coilNum);
 
-    int GetHeatingCoilNumberOfStages(EnergyPlusData &state,
-                                     std::string const &CoilType, // must match coil types in this module
-                                     std::string const &CoilName, // must match coil names for the coil type
-                                     bool &ErrorsFound            // set to true if problem
-    );
+    void SetCoilDesicData(EnergyPlusData &state, int const coilNum, bool desicRegenCoil, int desicDehumNum);
 
-    // sets data to a coil that is used as a regeneration air heating coil in
-    // desiccant dehumidification system
-    void SetHeatingCoilData(EnergyPlusData &state,
-                            int CoilNum,                                            // Number of electric or gas heating Coil
-                            bool &ErrorsFound,                                      // Set to true if certain errors found
-                            ObjexxFCL::Optional_bool DesiccantRegenerationCoil = _, // Flag that this coil is used as regeneration air heating coil
-                            ObjexxFCL::Optional_int DesiccantDehumIndex = _         // Index for the desiccant dehum system where this caoil is used
-    );
-
-    void SetHeatingCoilAirLoopNumber(EnergyPlusData &state, std::string const &HeatingCoilName, int AirLoopNum, bool &ErrorsFound);
+    void SetCoilAirLoopNumber(EnergyPlusData &state, int const coilNum, int AirLoopNum);
 
 } // namespace HeatingCoils
 
@@ -304,11 +271,7 @@ struct HeatingCoilsData : BaseGlobalStruct
     Array1D<HeatingCoils::HeatingCoilEquipConditions> HeatingCoil;
     Array1D<HeatingCoils::HeatingCoilNumericFieldData> HeatingCoilNumericFields;
     bool MyOneTimeFlag = true; // one time initialization flag
-    bool InputErrorsFound = false;
 
-    int MaxNums = 0;                    // Maximum number of numeric input fields
-    int MaxAlphas = 0;                  // Maximum number of alpha input fields
-    int TotalArgs = 0;                  // Total number of alpha and numeric arguments (max) for a certain object in the input file
     int ValidSourceTypeCounter = 0;     // Counter used to determine if desuperheater source name is valid
     bool HeatingCoilFatalError = false; // used for error checking
     Array1D_bool MySPTestFlag;          // used for error checking
@@ -339,10 +302,6 @@ struct HeatingCoilsData : BaseGlobalStruct
         this->HeatingCoil.deallocate();
         this->HeatingCoilNumericFields.deallocate();
         this->MyOneTimeFlag = true;
-        this->InputErrorsFound = false;
-        this->MaxNums = 0;
-        this->MaxAlphas = 0;
-        this->TotalArgs = 0;
         this->ValidSourceTypeCounter = 0;
         this->HeatingCoilFatalError = false;
         this->MySPTestFlag.clear();
@@ -354,3 +313,4 @@ struct HeatingCoilsData : BaseGlobalStruct
 } // namespace EnergyPlus
 
 #endif
+
diff --git a/src/EnergyPlus/IntegratedHeatPump.cc b/src/EnergyPlus/IntegratedHeatPump.cc
index 6a12ab136ca..91fd90f9313 100644
--- a/src/EnergyPlus/IntegratedHeatPump.cc
+++ b/src/EnergyPlus/IntegratedHeatPump.cc
@@ -96,11 +96,6 @@ void SimIHP(EnergyPlusData &state,
     // PURPOSE OF THIS SUBROUTINE:
     // This subroutine manages variable-speed integrated Air source heat pump simulation.
 
-    // Using/Aliasing
-    using VariableSpeedCoils::InitVarSpeedCoil;
-    using VariableSpeedCoils::SimVariableSpeedCoils;
-    using VariableSpeedCoils::UpdateVarSpeedCoil;
-
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
     int DXCoilNum(0); // The IHP No that you are currently dealing with
 
@@ -132,13 +127,43 @@ void SimIHP(EnergyPlusData &state,
                                   CompName,
                                   state.dataIntegratedHP->IntegratedHeatPumps(DXCoilNum).Name));
         }
-    };
+    }
 
-    auto &ihp = state.dataIntegratedHP->IntegratedHeatPumps(DXCoilNum);
+    SimIHP(state,
+           DXCoilNum,
+           fanOp,
+           compressorOp, 
+           PartLoadFrac,
+           SpeedNum,
+           SpeedRatio,
+           SensLoad,
+           LatentLoad,
+           IsCallbyWH,
+           FirstHVACIteration,
+           OnOffAirFlowRat);
 
-    if (!ihp.IHPCoilsSized) SizeIHP(state, DXCoilNum);
+}
+  
+void SimIHP(EnergyPlusData &state,
+            int const ihpNum,
+            HVAC::FanOp const fanOp,               // Continuous fan OR cycling compressor
+            HVAC::CompressorOp const compressorOp, // compressor on/off. 0 = off; 1= on
+            Real64 const PartLoadFrac,             // part load fraction
+            int const SpeedNum,                    // compressor speed number
+            Real64 const SpeedRatio,               // compressor speed ratio
+            Real64 const SensLoad,                 // Sensible demand load [W]
+            Real64 const LatentLoad,               // Latent demand load [W]
+            bool const IsCallbyWH,                 // whether the call from the water heating loop or air loop, true = from water heating loop
+            [[maybe_unused]] bool const FirstHVACIteration,   // TRUE if First iteration of simulation
+            ObjexxFCL::Optional<Real64 const> OnOffAirFlowRat // ratio of comp on to comp off air flow rate
+)
+{
+    assert(ihpNum >= 0 && ihpNum <= state.dataIntegratedHP->IntegratedHeatPumps.size());
+    auto &ihp = state.dataIntegratedHP->IntegratedHeatPumps(ihpNum);
+
+    if (!ihp.IHPCoilsSized) SizeIHP(state, ihpNum);
 
-    InitializeIHP(state, DXCoilNum);
+    InitializeIHP(state, ihpNum);
 
     Real64 airMassFlowRate = state.dataLoopNodes->Node(ihp.AirCoolInletNodeNum).MassFlowRate;
     ihp.AirLoopFlowRate = airMassFlowRate;
@@ -147,16 +172,15 @@ void SimIHP(EnergyPlusData &state,
     case IHPOperationMode::SpaceClg:
         if (!IsCallbyWH) // process when called from air loop
         {
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SCCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHCoolCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHHeatCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.DWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SCCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -166,7 +190,7 @@ void SimIHP(EnergyPlusData &state,
                                   LatentLoad,
                                   OnOffAirFlowRat);
 
-            SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
 
             ihp.AirFlowSavInAirLoop = airMassFlowRate;
         }
@@ -176,17 +200,16 @@ void SimIHP(EnergyPlusData &state,
     case IHPOperationMode::SpaceHtg:
         if (!IsCallbyWH) // process when called from air loop
         {
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SHCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHCoolCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHHeatCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.DWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SHCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -203,17 +226,16 @@ void SimIHP(EnergyPlusData &state,
     case IHPOperationMode::DedicatedWaterHtg:
         if (IsCallbyWH) // process when called from water loop
         {
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.DWHCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHCoolCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHHeatCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.DWHCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -231,16 +253,15 @@ void SimIHP(EnergyPlusData &state,
     case IHPOperationMode::SCWHMatchSC:
         if (!IsCallbyWH) // process when called from air loop
         {
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SCWHCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHCoolCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHHeatCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.DWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SCWHCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -250,7 +271,7 @@ void SimIHP(EnergyPlusData &state,
                                   LatentLoad,
                                   OnOffAirFlowRat);
 
-            SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
 
             ihp.AirFlowSavInAirLoop = airMassFlowRate;
         }
@@ -261,16 +282,15 @@ void SimIHP(EnergyPlusData &state,
     case IHPOperationMode::SCWHMatchWH:
         if (IsCallbyWH) // process when called from water loop
         {
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SCWHCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHCoolCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHHeatCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.DWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SCWHCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -280,7 +300,7 @@ void SimIHP(EnergyPlusData &state,
                                   LatentLoad,
                                   OnOffAirFlowRat);
 
-            SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
 
             ihp.AirFlowSavInWaterLoop = airMassFlowRate;
         }
@@ -290,15 +310,14 @@ void SimIHP(EnergyPlusData &state,
     case IHPOperationMode::SpaceClgDedicatedWaterHtg:
         if (!IsCallbyWH) // process when called from air loop
         {
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SCDWHWHCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHHeatCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.DWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SCDWHWHCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -307,9 +326,8 @@ void SimIHP(EnergyPlusData &state,
                                   SensLoad,
                                   LatentLoad,
                                   OnOffAirFlowRat);
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SCDWHCoolCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SCDWHCoolCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -319,7 +337,7 @@ void SimIHP(EnergyPlusData &state,
                                   LatentLoad,
                                   OnOffAirFlowRat);
 
-            SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
 
             ihp.AirFlowSavInAirLoop = airMassFlowRate;
         }
@@ -330,16 +348,15 @@ void SimIHP(EnergyPlusData &state,
     case IHPOperationMode::SHDWHElecHeatOn:
         if (!IsCallbyWH) // process when called from air loop
         {
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-            SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SHDWHWHCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHCoolCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+            VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.DWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SHDWHWHCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -348,9 +365,8 @@ void SimIHP(EnergyPlusData &state,
                                   SensLoad,
                                   LatentLoad,
                                   OnOffAirFlowRat);
-            SimVariableSpeedCoils(state,
-                                  std::string(),
-                                  ihp.SHDWHHeatCoilIndex,
+            VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                  ihp.SHDWHHeatCoilNum,
                                   fanOp,
                                   compressorOp,
                                   PartLoadFrac,
@@ -367,21 +383,21 @@ void SimIHP(EnergyPlusData &state,
         break;
     case IHPOperationMode::Idle:
     default: // clear up
-        SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-        SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-        SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-        SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-        SimVariableSpeedCoils(state, std::string(), ihp.SCWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-        SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-        SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
-        SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHCoolCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHHeatCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHDWHWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SCCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.SHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
+        VariableSpeedCoils::SimVariableSpeedCoils(state, ihp.DWHCoilNum, fanOp, compressorOp, 0.0, 1, 0.0, 0.0, 0.0, OnOffAirFlowRat);
         ihp.TankSourceWaterMassFlowRate = 0.0;
         ihp.AirFlowSavInAirLoop = 0.0;
         ihp.AirFlowSavInWaterLoop = 0.0;
         break;
     }
 
-    UpdateIHP(state, DXCoilNum);
+    UpdateIHP(state, ihpNum);
 }
 
 void GetIHPInput(EnergyPlusData &state)
@@ -405,10 +421,10 @@ void GetIHPInput(EnergyPlusData &state)
     using BranchNodeConnections::SetUpCompSets;
     using BranchNodeConnections::TestCompSet;
     using GlobalNames::VerifyUniqueCoilName;
-    using VariableSpeedCoils::GetCoilIndexVariableSpeed;
 
     // SUBROUTINE PARAMETER DEFINITIONS:
     static constexpr std::string_view RoutineName("GetIHPInput: "); // include trailing blank space
+    static constexpr std::string_view routineName = "GetIHPInput"; 
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
     int NumAlphas;                   // Number of variables in String format
@@ -466,6 +482,8 @@ void GetIHPInput(EnergyPlusData &state)
                                                                  cAlphaFields,
                                                                  cNumericFields);
 
+        ErrorObjectHeader eoh{routineName, CurrentModuleObject, AlphArray(1)};
+        
         // ErrorsFound will be set to True if problem was found, left untouched otherwise
         VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
 
@@ -476,144 +494,88 @@ void GetIHPInput(EnergyPlusData &state)
 
         // AlphArray( 2 ) is the water sensor node
 
-        ihp.SCCoilType = "COIL:COOLING:DX:VARIABLESPEED";
+        ihp.SCCoilType = HVAC::CoilType::CoolingDXVariableSpeed;
         ihp.SCCoilName = AlphArray(3);
         ihp.SCCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed;
 
-        ValidateComponent(state, ihp.SCCoilType, ihp.SCCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.SCCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.SCCoilName);
+        if (ihp.SCCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(3), ihp.SCCoilName);
             ErrorsFound = true;
-        } else {
-            errFlag = false;
-            ihp.SCCoilIndex = GetCoilIndexVariableSpeed(state, ihp.SCCoilType, ihp.SCCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            }
         }
 
-        ihp.SHCoilType = "COIL:HEATING:DX:VARIABLESPEED";
+        ihp.SHCoilType = HVAC::CoilType::HeatingDXVariableSpeed;
         ihp.SHCoilName = AlphArray(4);
         ihp.SHCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilHeatingDXVariableSpeed;
 
-        ValidateComponent(state, ihp.SHCoilType, ihp.SHCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.SHCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.SHCoilName);
+        if (ihp.SHCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(4), ihp.SHCoilName);
             ErrorsFound = true;
-        } else {
-            errFlag = false;
-            ihp.SHCoilIndex = GetCoilIndexVariableSpeed(state, ihp.SHCoilType, ihp.SHCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            }
         }
 
-        ihp.DWHCoilType = "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
+        ihp.DWHCoilType = HVAC::CoilType::WaterHeatingAWHPVariableSpeed;
         ihp.DWHCoilName = AlphArray(5);
         ihp.DWHCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed;
 
-        ValidateComponent(state, ihp.DWHCoilType, ihp.DWHCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.DWHCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.DWHCoilName);
+        if (ihp.DWHCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(5), ihp.DWHCoilName);
             ErrorsFound = true;
-        } else {
-            errFlag = false;
-            ihp.DWHCoilIndex = GetCoilIndexVariableSpeed(state, ihp.DWHCoilType, ihp.DWHCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            }
         }
 
-        ihp.SCWHCoilType = "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
+        ihp.SCWHCoilType = HVAC::CoilType::WaterHeatingAWHPVariableSpeed;
         ihp.SCWHCoilName = AlphArray(6);
         ihp.SCWHCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed;
 
-        ValidateComponent(state, ihp.SCWHCoilType, ihp.SCWHCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.SCWHCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.SCWHCoilName);
+        if (ihp.SCWHCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(6), ihp.SCWHCoilName);
             ErrorsFound = true;
-        } else {
-            errFlag = false;
-            ihp.SCWHCoilIndex = GetCoilIndexVariableSpeed(state, ihp.SCWHCoilType, ihp.SCWHCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            }
         }
 
-        ihp.SCDWHCoolCoilType = "COIL:COOLING:DX:VARIABLESPEED";
+        ihp.SCDWHCoolCoilType = HVAC::CoilType::CoolingDXVariableSpeed;
         ihp.SCDWHCoolCoilName = AlphArray(7);
         ihp.SCDWHCoolCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed;
 
-        ValidateComponent(state, ihp.SCDWHCoolCoilType, ihp.SCDWHCoolCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.SCDWHCoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.SCDWHCoolCoilName);
+        if (ihp.SCDWHCoolCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(7), ihp.SCDWHCoolCoilName);
             ErrorsFound = true;
-        } else {
-            errFlag = false;
-            ihp.SCDWHCoolCoilIndex = GetCoilIndexVariableSpeed(state, ihp.SCDWHCoolCoilType, ihp.SCDWHCoolCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            }
         }
 
-        ihp.SCDWHWHCoilType = "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
+        ihp.SCDWHWHCoilType = HVAC::CoilType::WaterHeatingAWHPVariableSpeed;
         ihp.SCDWHWHCoilName = AlphArray(8);
         ihp.SCDWHWHCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed;
 
-        ValidateComponent(state, ihp.SCDWHWHCoilType, ihp.SCDWHWHCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.SCDWHWHCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.SCDWHWHCoilName);
+        if (ihp.SCDWHWHCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(8), ihp.SCDWHWHCoilName);
             ErrorsFound = true;
         } else {
-            errFlag = false;
-            ihp.SCDWHWHCoilIndex = GetCoilIndexVariableSpeed(state, ihp.SCDWHWHCoilType, ihp.SCDWHWHCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            } else {
-                state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).bIsDesuperheater = true;
-            }
+            state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).bIsDesuperheater = true;
         }
 
-        ihp.SHDWHHeatCoilType = "COIL:HEATING:DX:VARIABLESPEED";
+        ihp.SHDWHHeatCoilType = HVAC::CoilType::HeatingDXVariableSpeed;
         ihp.SHDWHHeatCoilName = AlphArray(9);
         ihp.SHDWHHeatCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilHeatingDXVariableSpeed;
 
-        ValidateComponent(state, ihp.SHDWHHeatCoilType, ihp.SHDWHHeatCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.SHDWHHeatCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.SHDWHHeatCoilName);
+        if (ihp.SHDWHHeatCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(9), ihp.SHDWHHeatCoilName);
             ErrorsFound = true;
-        } else {
-            errFlag = false;
-            ihp.SHDWHHeatCoilIndex = GetCoilIndexVariableSpeed(state, ihp.SHDWHHeatCoilType, ihp.SHDWHHeatCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            }
         }
 
-        ihp.SHDWHWHCoilType = "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
+        ihp.SHDWHWHCoilType = HVAC::CoilType::WaterHeatingAWHPVariableSpeed;
         ihp.SHDWHWHCoilName = AlphArray(10);
         ihp.SHDWHWHCoilTypeNum = DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed;
 
-        ValidateComponent(state, ihp.SHDWHWHCoilType, ihp.SHDWHWHCoilName, IsNotOK, CurrentModuleObject);
-        if (IsNotOK) {
-            ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
+        ihp.SHDWHWHCoilNum = VariableSpeedCoils::GetCoilIndex(state, ihp.SHDWHWHCoilName);
+        if (ihp.SHDWHWHCoilNum == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(10), ihp.SHDWHWHCoilName);
             ErrorsFound = true;
         } else {
-            errFlag = false;
-            ihp.SHDWHWHCoilIndex = GetCoilIndexVariableSpeed(state, ihp.SHDWHWHCoilType, ihp.SHDWHWHCoilName, errFlag);
-            if (errFlag) {
-                ShowContinueError(state, format("...specified in {}=\"{}\".", CurrentModuleObject, AlphArray(1)));
-                ErrorsFound = true;
-            } else {
-                state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).bIsDesuperheater = true;
-            }
+            state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).bIsDesuperheater = true;
         }
 
         ihp.TindoorOverCoolAllow = NumArray(1);
@@ -640,7 +602,7 @@ void GetIHPInput(EnergyPlusData &state)
         //     using OverrideNodeConnectionType
 
         // cooling coil air node connections
-        int ChildCoilIndex = ihp.SCCoilIndex;
+        int ChildCoilIndex = ihp.SCCoilNum;
         int InNode = state.dataVariableSpeedCoils->VarSpeedCoil(ChildCoilIndex).AirInletNodeNum;
         int OutNode = state.dataVariableSpeedCoils->VarSpeedCoil(ChildCoilIndex).AirOutletNodeNum;
         std::string InNodeName = state.dataLoopNodes->NodeID(InNode);
@@ -669,7 +631,7 @@ void GetIHPInput(EnergyPlusData &state)
                                ObjectIsNotParent,
                                ErrorsFound);
 
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Cooling Coil", ihp.SCCoilType, ihp.SCCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Cooling Coil", HVAC::coilTypeNames[(int)ihp.SCCoilType], ihp.SCCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -689,12 +651,12 @@ void GetIHPInput(EnergyPlusData &state)
                                    ObjectIsNotParent,
                                    ErrorsFound);
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).AirInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).AirOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).AirInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).AirOutletNodeNum != OutNode)) {
             ShowContinueError(state, format("Mistaken air node connection: {}{}-wrong coil node names.", CurrentModuleObject, ihp.SCWHCoilName));
             ErrorsFound = true;
         }
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Cooling Coil", ihp.SCWHCoilType, ihp.SCWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Cooling Coil", HVAC::coilTypeNames[(int)ihp.SCWHCoilType], ihp.SCWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -714,12 +676,12 @@ void GetIHPInput(EnergyPlusData &state)
                                    ObjectIsNotParent,
                                    ErrorsFound);
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).AirInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).AirOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).AirInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).AirOutletNodeNum != OutNode)) {
             ShowContinueError(state, format("Mistaken air node connection: {}{}-wrong coil node names.", CurrentModuleObject, ihp.SCDWHCoolCoilName));
             ErrorsFound = true;
         }
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Cooling Coil", ihp.SCDWHCoolCoilType, ihp.SCDWHCoolCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Cooling Coil", HVAC::coilTypeNames[(int)ihp.SCDWHCoolCoilType], ihp.SCDWHCoolCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -740,7 +702,7 @@ void GetIHPInput(EnergyPlusData &state)
                                    ErrorsFound);
 
         // heating coil air node connections
-        ChildCoilIndex = ihp.SHCoilIndex;
+        ChildCoilIndex = ihp.SHCoilNum;
 
         InNode = ihp.AirHeatInletNodeNum;
         OutNode = state.dataVariableSpeedCoils->VarSpeedCoil(ChildCoilIndex).AirOutletNodeNum;
@@ -772,7 +734,7 @@ void GetIHPInput(EnergyPlusData &state)
                                ObjectIsNotParent,
                                ErrorsFound);
 
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Heating Coil", ihp.SHCoilType, ihp.SHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Heating Coil", HVAC::coilTypeNames[(int)ihp.SHCoilType], ihp.SHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -792,13 +754,13 @@ void GetIHPInput(EnergyPlusData &state)
                                    ObjectIsNotParent,
                                    ErrorsFound);
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilIndex).AirInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilIndex).AirOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilNum).AirInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilNum).AirOutletNodeNum != OutNode)) {
             ShowContinueError(state,
                               format("Mistaken air node connection: {}:{}-wrong coil node names.", CurrentModuleObject, ihp.SHDWHHeatCoilName));
             ErrorsFound = true;
         }
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Heating Coil", ihp.SHDWHHeatCoilType, ihp.SHDWHHeatCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Heating Coil", HVAC::coilTypeNames[(int)ihp.SHDWHHeatCoilType], ihp.SHDWHHeatCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -819,7 +781,7 @@ void GetIHPInput(EnergyPlusData &state)
                                    ErrorsFound);
 
         // water node connections
-        ChildCoilIndex = ihp.SCWHCoilIndex;
+        ChildCoilIndex = ihp.SCWHCoilNum;
 
         InNode = state.dataVariableSpeedCoils->VarSpeedCoil(ChildCoilIndex).WaterInletNodeNum;
         OutNode = state.dataVariableSpeedCoils->VarSpeedCoil(ChildCoilIndex).WaterOutletNodeNum;
@@ -827,8 +789,8 @@ void GetIHPInput(EnergyPlusData &state)
         OutNodeName = state.dataLoopNodes->NodeID(OutNode);
         ihp.WaterInletNodeNum = InNode;
         ihp.WaterOutletNodeNum = OutNode;
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).WaterInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).WaterOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).WaterInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).WaterOutletNodeNum != OutNode)) {
             ShowContinueError(state, format("Mistaken air node connection: {}:{}-wrong coil node names.", CurrentModuleObject, ihp.SCDWHWHCoilName));
             ErrorsFound = true;
         }
@@ -853,7 +815,7 @@ void GetIHPInput(EnergyPlusData &state)
                                ObjectIsNotParent,
                                ErrorsFound);
 
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", ihp.SCWHCoilType, ihp.SCWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", HVAC::coilTypeNames[(int)ihp.SCWHCoilType], ihp.SCWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -873,7 +835,7 @@ void GetIHPInput(EnergyPlusData &state)
                                    ObjectIsNotParent,
                                    ErrorsFound);
 
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", ihp.SCDWHWHCoilType, ihp.SCDWHWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", HVAC::coilTypeNames[(int)ihp.SCDWHWHCoilType], ihp.SCDWHWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -893,12 +855,12 @@ void GetIHPInput(EnergyPlusData &state)
                                    ObjectIsNotParent,
                                    ErrorsFound);
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).WaterInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).WaterOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).WaterInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).WaterOutletNodeNum != OutNode)) {
             ShowContinueError(state, format("Mistaken air node connection: {}:{}-wrong coil node names.", CurrentModuleObject, ihp.SHDWHWHCoilName));
             ErrorsFound = true;
         }
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", ihp.SHDWHWHCoilType, ihp.SHDWHWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", HVAC::coilTypeNames[(int)ihp.SHDWHWHCoilType], ihp.SHDWHWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -918,12 +880,12 @@ void GetIHPInput(EnergyPlusData &state)
                                    ObjectIsNotParent,
                                    ErrorsFound);
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).WaterInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).WaterOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).WaterInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).WaterOutletNodeNum != OutNode)) {
             ShowContinueError(state, format("Mistaken air node connection: {}:{}-wrong coil node names.", CurrentModuleObject, ihp.DWHCoilName));
             ErrorsFound = true;
         }
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", ihp.DWHCoilType, ihp.DWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Water Coil", HVAC::coilTypeNames[(int)ihp.DWHCoilType], ihp.DWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -955,15 +917,15 @@ void GetIHPInput(EnergyPlusData &state)
 
         // outdoor air node connections for water heating coils
         // DWH, SCDWH, SHDWH coils have the same outdoor air nodes
-        ChildCoilIndex = ihp.DWHCoilIndex;
+        ChildCoilIndex = ihp.DWHCoilNum;
         InNode = state.dataVariableSpeedCoils->VarSpeedCoil(ChildCoilIndex).AirInletNodeNum;
         OutNode = state.dataVariableSpeedCoils->VarSpeedCoil(ChildCoilIndex).AirOutletNodeNum;
         InNodeName = state.dataLoopNodes->NodeID(InNode);
         OutNodeName = state.dataLoopNodes->NodeID(OutNode);
         ihp.ODAirInletNodeNum = InNode;
         ihp.ODAirOutletNodeNum = OutNode;
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).AirInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).AirOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).AirInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).AirOutletNodeNum != OutNode)) {
             ShowContinueError(state, format("Mistaken air node connection: {}:{}-wrong coil node names.", CurrentModuleObject, ihp.SCDWHWHCoilName));
             ErrorsFound = true;
         }
@@ -988,7 +950,7 @@ void GetIHPInput(EnergyPlusData &state)
                                ObjectIsNotParent,
                                ErrorsFound);
 
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Outdoor Coil", ihp.DWHCoilType, ihp.DWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Outdoor Coil", HVAC::coilTypeNames[(int)ihp.DWHCoilType], ihp.DWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -1008,7 +970,7 @@ void GetIHPInput(EnergyPlusData &state)
                                    ObjectIsNotParent,
                                    ErrorsFound);
 
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Outdoor Coil", ihp.SCDWHWHCoilType, ihp.SCDWHWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Outdoor Coil", HVAC::coilTypeNames[(int)ihp.SCDWHWHCoilType], ihp.SCDWHWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -1032,12 +994,12 @@ void GetIHPInput(EnergyPlusData &state)
         //        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).AirInletNodeNum = InNode;
         //        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).AirOutletNodeNum = OutNode;
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).AirInletNodeNum != InNode) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).AirOutletNodeNum != OutNode)) {
+        if ((state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).AirInletNodeNum != InNode) ||
+            (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).AirOutletNodeNum != OutNode)) {
             ShowContinueError(state, format("Mistaken air node connection: {}:{}-wrong coil node names.", CurrentModuleObject, ihp.SHDWHWHCoilName));
             ErrorsFound = true;
         }
-        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Outdoor Coil", ihp.SHDWHWHCoilType, ihp.SHDWHWHCoilName, InNodeName, OutNodeName);
+        SetUpCompSets(state, CurrentModuleObject, ihp.Name + " Outdoor Coil", HVAC::coilTypeNames[(int)ihp.SHDWHWHCoilType], ihp.SHDWHWHCoilName, InNodeName, OutNodeName);
         OverrideNodeConnectionType(state,
                                    InNode,
                                    InNodeName,
@@ -1188,9 +1150,6 @@ void GetIHPInput(EnergyPlusData &state)
 void SizeIHP(EnergyPlusData &state, int const DXCoilNum)
 {
     using DataSizing::AutoSize;
-    using VariableSpeedCoils::SetVarSpeedCoilData;
-    using VariableSpeedCoils::SimVariableSpeedCoils;
-    using VariableSpeedCoils::SizeVarSpeedCoil;
 
     bool ErrorsFound = false;
     Real64 RatedCapacity(0.0); // rated building cooling load
@@ -1216,38 +1175,38 @@ void SizeIHP(EnergyPlusData &state, int const DXCoilNum)
 
     // associate SC coil with SH coil
     bool errFlag = false;
-    SetVarSpeedCoilData(state, ihp.SCCoilIndex, errFlag, _, ihp.SHCoilIndex);
+    VariableSpeedCoils::SetCoilData(state, ihp.SCCoilNum, _, ihp.SHCoilNum);
     if (errFlag) {
         ShowSevereError(state, format(R"(SizeIHP: Could not match cooling coil"{}" with heating coil="{}")", ihp.SCCoilName, ihp.SHCoilName));
         ErrorsFound = true;
     };
 
     errFlag = false;
-    SizeVarSpeedCoil(state, ihp.SCCoilIndex, errFlag); // size cooling coil
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.SCCoilNum, errFlag); // size cooling coil
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size SC coil\"{}\"", ihp.SCCoilName));
         ErrorsFound = true;
     } else {
-        RatedCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilIndex).RatedCapCoolTotal;
+        RatedCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilNum).RatedCapCoolTotal;
     };
 
     errFlag = false;
-    SizeVarSpeedCoil(state, ihp.SHCoilIndex, errFlag); // size heating coil
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.SHCoilNum, errFlag); // size heating coil
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size SH coil\"{}\"", ihp.SHCoilName));
         ErrorsFound = true;
     };
 
     // pass SC coil capacity to SCDWH cool coil
-    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).RatedCapCoolTotal == AutoSize) {
-        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).RatedCapCoolTotal = RatedCapacity;
+    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).RatedCapCoolTotal == AutoSize) {
+        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).RatedCapCoolTotal = RatedCapacity;
     };
 
     // associate SCDWH air coil to SHDWH air coil
     errFlag = false;
-    SetVarSpeedCoilData(state, ihp.SCDWHCoolCoilIndex, errFlag, _, ihp.SHDWHHeatCoilIndex);
+    VariableSpeedCoils::SetCoilData(state, ihp.SCDWHCoolCoilNum, _, ihp.SHDWHHeatCoilNum);
     // size SCDWH air coil
-    SizeVarSpeedCoil(state, ihp.SCDWHCoolCoilIndex, errFlag);
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.SCDWHCoolCoilNum, errFlag);
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size SCDWH cooling coil\"{}\"", ihp.SCDWHCoolCoilName));
         ErrorsFound = true;
@@ -1255,7 +1214,7 @@ void SizeIHP(EnergyPlusData &state, int const DXCoilNum)
 
     // size SHDWH air coil
     errFlag = false;
-    SizeVarSpeedCoil(state, ihp.SHDWHHeatCoilIndex, errFlag);
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.SHDWHHeatCoilNum, errFlag);
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size SHDWH heating coil\"{}\"", ihp.SHDWHHeatCoilName));
         ErrorsFound = true;
@@ -1263,49 +1222,49 @@ void SizeIHP(EnergyPlusData &state, int const DXCoilNum)
 
     // size the water coils below
     // size SCWH water coil
-    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).RatedCapWH == AutoSize) {
-        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).RatedCapWH =
-            RatedCapacity / (1.0 - 1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).RatedCOPHeat);
+    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).RatedCapWH == AutoSize) {
+        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).RatedCapWH =
+            RatedCapacity / (1.0 - 1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).RatedCOPHeat);
     }
 
     errFlag = false;
-    SizeVarSpeedCoil(state, ihp.SCWHCoilIndex, errFlag);
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.SCWHCoilNum, errFlag);
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size SCWH coil\"{}\"", ihp.SCWHCoilName));
         ErrorsFound = true;
     };
 
     // size DWH water coil
-    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).RatedCapWH == AutoSize) {
-        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).RatedCapWH = RatedCapacity;
+    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).RatedCapWH == AutoSize) {
+        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).RatedCapWH = RatedCapacity;
     }
 
     errFlag = false;
-    SizeVarSpeedCoil(state, ihp.DWHCoilIndex, errFlag);
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.DWHCoilNum, errFlag);
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size DWH coil\"{}\"", ihp.DWHCoilName));
         ErrorsFound = true;
     };
 
     // size SCDWH water coil
-    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).RatedCapWH == AutoSize) {
-        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).RatedCapWH = RatedCapacity * 0.13;
+    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).RatedCapWH == AutoSize) {
+        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).RatedCapWH = RatedCapacity * 0.13;
     }
 
     errFlag = false;
-    SizeVarSpeedCoil(state, ihp.SCDWHWHCoilIndex, errFlag);
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.SCDWHWHCoilNum, errFlag);
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size SCDWH water heating coil\"{}\"", ihp.SCDWHWHCoilName));
         ErrorsFound = true;
     };
 
     // size SHDWH water coil
-    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).RatedCapWH == AutoSize) {
-        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).RatedCapWH = RatedCapacity * 0.1;
+    if (state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).RatedCapWH == AutoSize) {
+        state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).RatedCapWH = RatedCapacity * 0.1;
     }
 
     errFlag = false;
-    SizeVarSpeedCoil(state, ihp.SHDWHWHCoilIndex, errFlag);
+    VariableSpeedCoils::SizeVarSpeedCoil(state, ihp.SHDWHWHCoilNum, errFlag);
     if (errFlag) {
         ShowSevereError(state, format("SizeIHP: failed to size SHDWH water heating coil\"{}\"", ihp.SHDWHWHCoilName));
         ErrorsFound = true;
@@ -1373,57 +1332,57 @@ void UpdateIHP(EnergyPlusData &state, int const DXCoilNum)
 
     switch (ihp.CurMode) {
     case IHPOperationMode::SpaceClg:
-        ihp.TotalCoolingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilIndex).QLoadTotal; // total cooling rate [w]
+        ihp.TotalCoolingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilNum).QLoadTotal; // total cooling rate [w]
         ihp.TotalWaterHeatingRate = 0.0;                                                               // total water heating rate [w]
         ihp.TotalSpaceHeatingRate = 0.0;                                                               // total space heating rate [w]
-        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilIndex).Power;            // total power consumption  [w]
-        ihp.TotalLatentLoad = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilIndex).QLatent;     // total latent cooling rate [w]
-        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilIndex).QSource;             // source energy rate, [w]
+        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilNum).Power;            // total power consumption  [w]
+        ihp.TotalLatentLoad = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilNum).QLatent;     // total latent cooling rate [w]
+        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilNum).QSource;             // source energy rate, [w]
         break;
     case IHPOperationMode::SpaceHtg:
         ihp.TotalCoolingRate = 0.0;                                                                         // total cooling rate [w]
         ihp.TotalWaterHeatingRate = 0.0;                                                                    // total water heating rate [w]
-        ihp.TotalSpaceHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilIndex).QLoadTotal; // total space heating rate [w]
-        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilIndex).Power;                 // total power consumption  [w]
+        ihp.TotalSpaceHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilNum).QLoadTotal; // total space heating rate [w]
+        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilNum).Power;                 // total power consumption  [w]
         ihp.TotalLatentLoad = 0.0;                                                                          // total latent cooling rate [w]
-        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilIndex).QSource;                  // source energy rate, [w]
+        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilNum).QSource;                  // source energy rate, [w]
         break;
     case IHPOperationMode::DedicatedWaterHtg:
         ihp.TotalCoolingRate = 0.0;                                                                       // total cooling rate [w]
-        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).QSource; // total water heating rate [w]
+        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).QSource; // total water heating rate [w]
         ihp.TotalSpaceHeatingRate = 0.0;                                                                  // total space heating rate [w]
-        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).Power;              // total power consumption  [w]
+        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).Power;              // total power consumption  [w]
         ihp.TotalLatentLoad = 0.0;                                                                        // total latent cooling rate [w]
-        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).QLoadTotal;            // source energy rate, [w]
+        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).QLoadTotal;            // source energy rate, [w]
         break;
     case IHPOperationMode::SCWHMatchSC:
     case IHPOperationMode::SCWHMatchWH:
-        ihp.TotalCoolingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).QLoadTotal;   // total cooling rate [w]
-        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).QSource; // total water heating rate [w]
+        ihp.TotalCoolingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).QLoadTotal;   // total cooling rate [w]
+        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).QSource; // total water heating rate [w]
         ihp.TotalSpaceHeatingRate = 0.0;                                                                   // total space heating rate [w]
-        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).Power;              // total power consumption  [w]
-        ihp.TotalLatentLoad = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).QLatent;       // total latent cooling rate [w]
+        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).Power;              // total power consumption  [w]
+        ihp.TotalLatentLoad = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).QLatent;       // total latent cooling rate [w]
         ihp.Qsource = 0.0;                                                                                 // source energy rate, [w]
         break;
     case IHPOperationMode::SpaceClgDedicatedWaterHtg:
-        ihp.TotalCoolingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).QLoadTotal; // total cooling rate [w]
+        ihp.TotalCoolingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).QLoadTotal; // total cooling rate [w]
         ihp.TotalSpaceHeatingRate = 0.0;                                                                      // total space heating rate [w]
-        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).Power;            // total power consumption  [w]
-        ihp.TotalLatentLoad = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).QLatent;     // total latent cooling rate [w]
-        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).QSource;             // source energy rate, [w]
+        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).Power;            // total power consumption  [w]
+        ihp.TotalLatentLoad = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).QLatent;     // total latent cooling rate [w]
+        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).QSource;             // source energy rate, [w]
 
-        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilIndex).QSource; // total water heating rate [w]
+        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHWHCoilNum).QSource; // total water heating rate [w]
 
         break;
     case IHPOperationMode::SHDWHElecHeatOff:
     case IHPOperationMode::SHDWHElecHeatOn:
         ihp.TotalCoolingRate = 0.0;                                                                                // total cooling rate [w]
-        ihp.TotalSpaceHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilIndex).QLoadTotal; // total space heating rate [w]
-        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilIndex).Power;                 // total power consumption  [w]
+        ihp.TotalSpaceHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilNum).QLoadTotal; // total space heating rate [w]
+        ihp.TotalPower = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilNum).Power;                 // total power consumption  [w]
         ihp.TotalLatentLoad = 0.0;                                                                                 // total latent cooling rate [w]
-        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilIndex).QSource;                  // source energy rate, [w]
+        ihp.Qsource = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilNum).QSource;                  // source energy rate, [w]
 
-        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilIndex).QSource; // total water heating rate [w]
+        ihp.TotalWaterHeatingRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHWHCoilNum).QSource; // total water heating rate [w]
 
         break;
     case IHPOperationMode::Idle:
@@ -1603,8 +1562,6 @@ void DecideWorkMode(EnergyPlusData &state,
 
 void ClearCoils(EnergyPlusData &state, int const DXCoilNum)
 {
-    using VariableSpeedCoils::SimVariableSpeedCoils;
-
     // Obtains and Allocates WatertoAirHP related parameters from input file
     if (state.dataIntegratedHP->GetCoilsInputFlag) { // First time subroutine has been entered
         GetIHPInput(state);
@@ -1621,14 +1578,14 @@ void ClearCoils(EnergyPlusData &state, int const DXCoilNum)
     auto &ihp = state.dataIntegratedHP->IntegratedHeatPumps(DXCoilNum);
 
     // clear up
-    SimVariableSpeedCoils(state, std::string(), ihp.SCDWHCoolCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    SimVariableSpeedCoils(state, std::string(), ihp.SCDWHWHCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    SimVariableSpeedCoils(state, std::string(), ihp.SHDWHHeatCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    SimVariableSpeedCoils(state, std::string(), ihp.SHDWHWHCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    SimVariableSpeedCoils(state, std::string(), ihp.SCWHCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    SimVariableSpeedCoils(state, std::string(), ihp.SCCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    SimVariableSpeedCoils(state, std::string(), ihp.SHCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
-    SimVariableSpeedCoils(state, std::string(), ihp.DWHCoilIndex, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SCDWHCoolCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SCDWHWHCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SHDWHHeatCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SHDWHWHCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SCWHCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SCCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.SHCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
+    VariableSpeedCoils::SimVariableSpeedCoils(state,  ihp.DWHCoilNum, HVAC::FanOp::Cycling, HVAC::CompressorOp::On, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
 }
 
 IHPOperationMode GetCurWorkMode(EnergyPlusData &state, int const DXCoilNum)
@@ -1844,9 +1801,6 @@ int GetIHPDWHCoilPLFFPLR(EnergyPlusData &state,
     // incorrect coil type or name is given, ErrorsFound is returned as true and value is returned
     // as zero.
 
-    // Using/Aliasing
-    using VariableSpeedCoils::GetVSCoilPLFFPLR;
-
     // Return value
     int PLRNumber(0); // returned outlet node of matched coil
 
@@ -1862,10 +1816,10 @@ int GetIHPDWHCoilPLFFPLR(EnergyPlusData &state,
         auto &ihp = state.dataIntegratedHP->IntegratedHeatPumps(WhichCoil);
 
         // this will be called by HPWH parent
-        if (ihp.DWHCoilIndex > 0)
-            PLRNumber = GetVSCoilPLFFPLR(state, ihp.DWHCoilType, ihp.DWHCoilName, ErrorsFound);
+        if (ihp.DWHCoilNum > 0)
+            PLRNumber = VariableSpeedCoils::GetCoilPLFFPLR(state, ihp.DWHCoilNum);
         else
-            PLRNumber = GetVSCoilPLFFPLR(state, ihp.SCWHCoilType, ihp.SCWHCoilName, ErrorsFound);
+            PLRNumber = VariableSpeedCoils::GetCoilPLFFPLR(state, ihp.SCWHCoilNum);
     } else {
         WhichCoil = 0;
     }
@@ -1898,9 +1852,6 @@ Real64 GetDWHCoilCapacityIHP(EnergyPlusData &state,
     // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
     // as negative.
 
-    // Using/Aliasing
-    using VariableSpeedCoils::GetCoilCapacityVariableSpeed;
-
     // Return value
     Real64 CoilCapacity; // returned capacity of matched coil
 
@@ -1917,10 +1868,10 @@ Real64 GetDWHCoilCapacityIHP(EnergyPlusData &state,
 
         if (ihp.IHPCoilsSized == false) SizeIHP(state, WhichCoil);
 
-        if (ihp.DWHCoilIndex > 0) {
-            CoilCapacity = GetCoilCapacityVariableSpeed(state, ihp.DWHCoilType, ihp.DWHCoilName, ErrorsFound);
+        if (ihp.DWHCoilNum > 0) {
+            CoilCapacity = VariableSpeedCoils::GetCoilCapacity(state, ihp.DWHCoilNum);
         } else {
-            CoilCapacity = GetCoilCapacityVariableSpeed(state, ihp.SCWHCoilType, ihp.SCWHCoilName, ErrorsFound);
+            CoilCapacity = VariableSpeedCoils::GetCoilCapacity(state, ihp.SCWHCoilNum);
         }
     } else {
         WhichCoil = 0;
@@ -2001,27 +1952,27 @@ int GetMaxSpeedNumIHP(EnergyPlusData &state, int const DXCoilNum)
     switch (ihp.CurMode) {
     case IHPOperationMode::Idle:
     case IHPOperationMode::SpaceClg:
-        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilIndex).NumOfSpeeds;
+        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilNum).NumOfSpeeds;
         break;
     case IHPOperationMode::SpaceHtg:
-        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilIndex).NumOfSpeeds;
+        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHCoilNum).NumOfSpeeds;
         break;
     case IHPOperationMode::DedicatedWaterHtg:
-        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilIndex).NumOfSpeeds;
+        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.DWHCoilNum).NumOfSpeeds;
         break;
     case IHPOperationMode::SCWHMatchSC:
     case IHPOperationMode::SCWHMatchWH:
-        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).NumOfSpeeds;
+        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).NumOfSpeeds;
         break;
     case IHPOperationMode::SpaceClgDedicatedWaterHtg:
-        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).NumOfSpeeds;
+        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).NumOfSpeeds;
         break;
     case IHPOperationMode::SHDWHElecHeatOff:
     case IHPOperationMode::SHDWHElecHeatOn:
-        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilIndex).NumOfSpeeds;
+        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilNum).NumOfSpeeds;
         break;
     default:
-        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilIndex).NumOfSpeeds;
+        SpeedNum = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCCoilNum).NumOfSpeeds;
         break;
     }
 
@@ -2060,10 +2011,10 @@ Real64 GetAirVolFlowRateIHP(EnergyPlusData &state,
     FlowScale = 0.0;
     switch (ihp.CurMode) {
     case IHPOperationMode::Idle:
-        IHPCoilIndex = ihp.SCCoilIndex;
+        IHPCoilIndex = ihp.SCCoilNum;
         break;
     case IHPOperationMode::SpaceClg:
-        IHPCoilIndex = ihp.SCCoilIndex;
+        IHPCoilIndex = ihp.SCCoilNum;
         if (!IsCallbyWH) // call from air loop
         {
             FlowScale = ihp.CoolVolFlowScale;
@@ -2071,52 +2022,52 @@ Real64 GetAirVolFlowRateIHP(EnergyPlusData &state,
 
         break;
     case IHPOperationMode::SpaceHtg:
-        IHPCoilIndex = ihp.SHCoilIndex;
+        IHPCoilIndex = ihp.SHCoilNum;
         if (!IsCallbyWH) // call from air loop
         {
             FlowScale = ihp.HeatVolFlowScale;
         }
         break;
     case IHPOperationMode::DedicatedWaterHtg:
-        IHPCoilIndex = ihp.DWHCoilIndex;
+        IHPCoilIndex = ihp.DWHCoilNum;
         FlowScale = 1.0;
         break;
     case IHPOperationMode::SCWHMatchSC:
-        IHPCoilIndex = ihp.SCWHCoilIndex;
+        IHPCoilIndex = ihp.SCWHCoilNum;
         FlowScale = ihp.CoolVolFlowScale;
         if (IsCallbyWH) // call from water loop
         {
             IsResultFlow = true;
-            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).AirVolFlowRate;
+            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).AirVolFlowRate;
         }
         break;
     case IHPOperationMode::SCWHMatchWH:
-        IHPCoilIndex = ihp.SCWHCoilIndex;
+        IHPCoilIndex = ihp.SCWHCoilNum;
         FlowScale = ihp.CoolVolFlowScale;
         if (!IsCallbyWH) {
             IsResultFlow = true;
-            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilIndex).AirVolFlowRate;
+            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCWHCoilNum).AirVolFlowRate;
         }
         break;
     case IHPOperationMode::SpaceClgDedicatedWaterHtg:
-        IHPCoilIndex = ihp.SCDWHCoolCoilIndex;
+        IHPCoilIndex = ihp.SCDWHCoolCoilNum;
         FlowScale = ihp.CoolVolFlowScale;
         if (IsCallbyWH) {
             IsResultFlow = true;
-            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilIndex).AirVolFlowRate;
+            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SCDWHCoolCoilNum).AirVolFlowRate;
         }
         break;
     case IHPOperationMode::SHDWHElecHeatOff:
     case IHPOperationMode::SHDWHElecHeatOn:
-        IHPCoilIndex = ihp.SHDWHHeatCoilIndex;
+        IHPCoilIndex = ihp.SHDWHHeatCoilNum;
         FlowScale = ihp.HeatVolFlowScale;
         if (IsCallbyWH) {
             IsResultFlow = true;
-            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilIndex).AirVolFlowRate;
+            AirVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(ihp.SHDWHHeatCoilNum).AirVolFlowRate;
         }
         break;
     default:
-        IHPCoilIndex = ihp.SCCoilIndex;
+        IHPCoilIndex = ihp.SCCoilNum;
         FlowScale = 0.0;
         break;
     }
@@ -2166,7 +2117,7 @@ Real64 GetWaterVolFlowRateIHP(EnergyPlusData &state, int const DXCoilNum, int co
         WaterVolFlowRate = 0.0;
         break;
     case IHPOperationMode::DedicatedWaterHtg:
-        IHPCoilIndex = ihp.DWHCoilIndex;
+        IHPCoilIndex = ihp.DWHCoilNum;
         if (1 == SpeedNum)
             WaterVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedWaterVolFlowRate(SpeedNum);
         else
@@ -2175,7 +2126,7 @@ Real64 GetWaterVolFlowRateIHP(EnergyPlusData &state, int const DXCoilNum, int co
         break;
     case IHPOperationMode::SCWHMatchSC:
     case IHPOperationMode::SCWHMatchWH:
-        IHPCoilIndex = ihp.SCWHCoilIndex;
+        IHPCoilIndex = ihp.SCWHCoilNum;
         if (1 == SpeedNum)
             WaterVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedWaterVolFlowRate(SpeedNum);
         else
@@ -2183,7 +2134,7 @@ Real64 GetWaterVolFlowRateIHP(EnergyPlusData &state, int const DXCoilNum, int co
                                (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedWaterVolFlowRate(SpeedNum - 1);
         break;
     case IHPOperationMode::SpaceClgDedicatedWaterHtg:
-        IHPCoilIndex = ihp.SCDWHWHCoilIndex;
+        IHPCoilIndex = ihp.SCDWHWHCoilNum;
         if (1 == SpeedNum)
             WaterVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedWaterVolFlowRate(SpeedNum);
         else
@@ -2192,7 +2143,7 @@ Real64 GetWaterVolFlowRateIHP(EnergyPlusData &state, int const DXCoilNum, int co
         break;
     case IHPOperationMode::SHDWHElecHeatOff:
     case IHPOperationMode::SHDWHElecHeatOn:
-        IHPCoilIndex = ihp.SHDWHWHCoilIndex;
+        IHPCoilIndex = ihp.SHDWHWHCoilNum;
         if (1 == SpeedNum)
             WaterVolFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(IHPCoilIndex).MSRatedWaterVolFlowRate(SpeedNum);
         else
@@ -2239,11 +2190,11 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
     FlowScale = 0.0;
     switch (ihp.CurMode) {
     case IHPOperationMode::Idle:
-        IHPCoilIndex = ihp.SCCoilIndex;
+        IHPCoilIndex = ihp.SCCoilNum;
         AirMassFlowRate = 0.0;
         break;
     case IHPOperationMode::SpaceClg:
-        IHPCoilIndex = ihp.SCCoilIndex;
+        IHPCoilIndex = ihp.SCCoilNum;
         if (!IsCallbyWH) {
             FlowScale = ihp.CoolVolFlowScale;
         } else {
@@ -2252,7 +2203,7 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
         }
         break;
     case IHPOperationMode::SpaceHtg:
-        IHPCoilIndex = ihp.SHCoilIndex;
+        IHPCoilIndex = ihp.SHCoilNum;
         if (!IsCallbyWH) {
             FlowScale = ihp.HeatVolFlowScale;
         } else {
@@ -2261,11 +2212,11 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
         }
         break;
     case IHPOperationMode::DedicatedWaterHtg:
-        IHPCoilIndex = ihp.DWHCoilIndex;
+        IHPCoilIndex = ihp.DWHCoilNum;
         FlowScale = 1.0;
         break;
     case IHPOperationMode::SCWHMatchSC:
-        IHPCoilIndex = ihp.SCWHCoilIndex;
+        IHPCoilIndex = ihp.SCWHCoilNum;
         FlowScale = ihp.CoolVolFlowScale;
         state.dataLoopNodes->Node(ihp.WaterInletNodeNum).MassFlowRate = GetWaterVolFlowRateIHP(state, DXCoilNum, SpeedNum, SpeedRatio) * WaterDensity;
         if (IsCallbyWH) {
@@ -2274,7 +2225,7 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
         }
         break;
     case IHPOperationMode::SCWHMatchWH:
-        IHPCoilIndex = ihp.SCWHCoilIndex;
+        IHPCoilIndex = ihp.SCWHCoilNum;
         FlowScale = ihp.CoolVolFlowScale;
         if (!IsCallbyWH) {
             IsResultFlow = true;
@@ -2282,7 +2233,7 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
         }
         break;
     case IHPOperationMode::SpaceClgDedicatedWaterHtg:
-        IHPCoilIndex = ihp.SCDWHCoolCoilIndex;
+        IHPCoilIndex = ihp.SCDWHCoolCoilNum;
         FlowScale = ihp.CoolVolFlowScale;
         state.dataLoopNodes->Node(ihp.WaterInletNodeNum).MassFlowRate = GetWaterVolFlowRateIHP(state, DXCoilNum, SpeedNum, SpeedRatio) * WaterDensity;
         if (IsCallbyWH) {
@@ -2292,7 +2243,7 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
         break;
     case IHPOperationMode::SHDWHElecHeatOff:
     case IHPOperationMode::SHDWHElecHeatOn:
-        IHPCoilIndex = ihp.SHDWHHeatCoilIndex;
+        IHPCoilIndex = ihp.SHDWHHeatCoilNum;
         FlowScale = ihp.HeatVolFlowScale;
         state.dataLoopNodes->Node(ihp.WaterInletNodeNum).MassFlowRate = GetWaterVolFlowRateIHP(state, DXCoilNum, SpeedNum, SpeedRatio) * WaterDensity;
         if (IsCallbyWH) {
@@ -2301,7 +2252,7 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
         }
         break;
     default:
-        IHPCoilIndex = ihp.SCCoilIndex;
+        IHPCoilIndex = ihp.SCCoilNum;
         FlowScale = 0.0;
         break;
     }
@@ -2332,4 +2283,49 @@ Real64 GetAirMassFlowRateIHP(EnergyPlusData &state,
     return AirMassFlowRate;
 }
 
+int GetIHPIndex(EnergyPlusData &state, std::string const &ihpName)
+{
+    if (state.dataIntegratedHP->GetCoilsInputFlag) { // First time subroutine has been entered
+        GetIHPInput(state);
+        state.dataIntegratedHP->GetCoilsInputFlag = false;
+    }
+
+    return Util::FindItemInList(ihpName, state.dataIntegratedHP->IntegratedHeatPumps);
+}
+  
+int GetIHPDWHCoilPLFFPLR(EnergyPlusData &state, int const ihpNum)
+{
+    assert(ihpNum > 0 && ihpNum <= state.dataIntegratedHP->IntegratedHeatPumps.size());
+    auto &ihp = state.dataIntegratedHP->IntegratedHeatPumps(ihpNum);
+    return (ihp.DWHCoilNum > 0) ?
+        VariableSpeedCoils::GetCoilPLFFPLR(state, ihp.DWHCoilNum) : VariableSpeedCoils::GetCoilPLFFPLR(state, ihp.SCWHCoilNum);
+}
+
+Real64 GetIHPDWHCoilCapacity(EnergyPlusData &state, int const ihpNum)
+{
+    assert(ihpNum > 0 && ihpNum <= state.dataIntegratedHP->IntegratedHeatPumps.size());
+    auto &ihp = state.dataIntegratedHP->IntegratedHeatPumps(ihpNum);
+    if (ihp.IHPCoilsSized == false) SizeIHP(state, ihpNum); // WHY?
+    return (ihp.DWHCoilNum > 0) ?
+        VariableSpeedCoils::GetCoilCapacity(state, ihp.DWHCoilNum) : VariableSpeedCoils::GetCoilCapacity(state, ihp.SCWHCoilNum);
+}
+
+int GetIHPCoilAirInletNode(EnergyPlusData &state, int const ihpNum)
+{
+    assert(ihpNum > 0 && ihpNum <= state.dataIntegratedHP->IntegratedHeatPumps.size());
+    return state.dataIntegratedHP->IntegratedHeatPumps(ihpNum).AirCoolInletNodeNum;
+}
+
+int GetIHPDWHCoilAirInletNode(EnergyPlusData &state, int const ihpNum)
+{
+    assert(ihpNum > 0 && ihpNum <= state.dataIntegratedHP->IntegratedHeatPumps.size());
+    return state.dataIntegratedHP->IntegratedHeatPumps(ihpNum).ODAirInletNodeNum;
+}
+
+int GetIHPDWHCoilAirOutletNode(EnergyPlusData &state, int const ihpNum)
+{
+    assert(ihpNum > 0 && ihpNum <= state.dataIntegratedHP->IntegratedHeatPumps.size());
+    return state.dataIntegratedHP->IntegratedHeatPumps(ihpNum).ODAirOutletNodeNum;
+}
+
 } // namespace EnergyPlus::IntegratedHeatPump
diff --git a/src/EnergyPlus/IntegratedHeatPump.hh b/src/EnergyPlus/IntegratedHeatPump.hh
index 1aac62921c5..9bbc77fface 100644
--- a/src/EnergyPlus/IntegratedHeatPump.hh
+++ b/src/EnergyPlus/IntegratedHeatPump.hh
@@ -89,44 +89,44 @@ namespace IntegratedHeatPump {
         std::string Name;    // Name of the  Coil
         std::string IHPtype; // type of coil
 
-        std::string SCCoilType; // Numeric Equivalent for SC Coil Type
+        HVAC::CoilType SCCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for SC Coil Type
         std::string SCCoilName;
-        int SCCoilIndex; // Index to SC coil
+        int SCCoilNum = 0; // Index to SC coil
         DataLoopNode::ConnectionObjectType SCCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
 
-        std::string SHCoilType; // Numeric Equivalent for SH Coil Type
+        HVAC::CoilType SHCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for SH Coil Type
         std::string SHCoilName;
-        int SHCoilIndex; // Index to SH coil
+        int SHCoilNum = 0; // Index to SH coil
         DataLoopNode::ConnectionObjectType SHCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
 
-        std::string SCWHCoilType; // Numeric Equivalent for SCWH Coil Type
+        HVAC::CoilType SCWHCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for SCWH Coil Type
         std::string SCWHCoilName;
-        int SCWHCoilIndex; // Index to SCWH coil
+        int SCWHCoilNum = 0; // Index to SCWH coil
         DataLoopNode::ConnectionObjectType SCWHCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
 
-        std::string DWHCoilType; // Numeric Equivalent for DWH Coil Type
+        HVAC::CoilType DWHCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for DWH Coil Type
         std::string DWHCoilName;
-        int DWHCoilIndex; // Index to DWH coil
+        int DWHCoilNum = 0; // Index to DWH coil
         DataLoopNode::ConnectionObjectType DWHCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
 
-        std::string SCDWHCoolCoilType; // Numeric Equivalent for SCDWH Coil Type, cooling part
+        HVAC::CoilType SCDWHCoolCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for SCDWH Coil Type, cooling part
         std::string SCDWHCoolCoilName;
-        int SCDWHCoolCoilIndex; // Index to SCDWH coil, cooling part
+        int SCDWHCoolCoilNum = 0; // Index to SCDWH coil, cooling part
         DataLoopNode::ConnectionObjectType SCDWHCoolCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
 
-        std::string SCDWHWHCoilType; // Numeric Equivalent for SCDWH Coil Type, water heating part
+        HVAC::CoilType SCDWHWHCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for SCDWH Coil Type, water heating part
         std::string SCDWHWHCoilName;
-        int SCDWHWHCoilIndex; // Index to SCDWH coil, water heating part
+        int SCDWHWHCoilNum = 0; // Index to SCDWH coil, water heating part
         DataLoopNode::ConnectionObjectType SCDWHWHCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
 
-        std::string SHDWHHeatCoilType; // Numeric Equivalent for SHDWH Coil Type, heating part
+        HVAC::CoilType SHDWHHeatCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for SHDWH Coil Type, heating part
         std::string SHDWHHeatCoilName;
-        int SHDWHHeatCoilIndex; // Index to SHDWH coil, heating part
+        int SHDWHHeatCoilNum = 0; // Index to SHDWH coil, heating part
         DataLoopNode::ConnectionObjectType SHDWHHeatCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
-
-        std::string SHDWHWHCoilType; // Numeric Equivalent for SHDWH Coil Type, water heating part
+ 
+        HVAC::CoilType SHDWHWHCoilType = HVAC::CoilType::Invalid; // Numeric Equivalent for SHDWH Coil Type, water heating part
         std::string SHDWHWHCoilName;
-        int SHDWHWHCoilIndex; // Index to SHDWH coil, water heating part
+        int SHDWHWHCoilNum = 0; // Index to SHDWH coil, water heating part
         DataLoopNode::ConnectionObjectType SHDWHWHCoilTypeNum = DataLoopNode::ConnectionObjectType::Invalid;
 
         int AirCoolInletNodeNum; // Node Number of the Air cooling coil Inlet
@@ -221,8 +221,7 @@ namespace IntegratedHeatPump {
 
         // Default Constructor
         IntegratedHeatPumpData()
-            : SCCoilIndex(0), SHCoilIndex(0), SCWHCoilIndex(0), DWHCoilIndex(0), SCDWHCoolCoilIndex(0), SCDWHWHCoilIndex(0), SHDWHHeatCoilIndex(0),
-              SHDWHWHCoilIndex(0), AirCoolInletNodeNum(0), AirHeatInletNodeNum(0), AirOutletNodeNum(0), WaterInletNodeNum(0), WaterOutletNodeNum(0),
+            : AirCoolInletNodeNum(0), AirHeatInletNodeNum(0), AirOutletNodeNum(0), WaterInletNodeNum(0), WaterOutletNodeNum(0),
               WaterTankoutNod(0), ModeMatchSCWH(0), MinSpedSCWH(1), MinSpedSCDWH(1), MinSpedSHDWH(1), TindoorOverCoolAllow(0.0),
               TambientOverCoolAllow(0.0), TindoorWHHighPriority(0.0), TambientWHHighPriority(0.0), WaterVolSCDWH(0.0), TimeLimitSHDWH(0.0),
               WHtankType(DataPlant::PlantEquipmentType::Invalid), WHtankID(0), LoopNum(0), LoopSideNum(0), IsWHCallAvail(false), CheckWHCall(false),
@@ -263,6 +262,20 @@ namespace IntegratedHeatPump {
                 ObjexxFCL::Optional<Real64 const> OnOffAirFlowRat = _ // ratio of comp on to comp off air flow rate
     );
 
+    void SimIHP(EnergyPlusData &state,
+                int const ihpNum,                  // Index for Component name
+                HVAC::FanOp const fanOp,         // Continuous fan OR cycling compressor
+                HVAC::CompressorOp compressorOp, // compressor on/off. 0 = off; 1= on
+                Real64 const PartLoadFrac,
+                int const SpeedNum,            // compressor speed number
+                Real64 const SpeedRatio,       // compressor speed ratio
+                Real64 const SensLoad,         // Sensible demand load [W]
+                Real64 const LatentLoad,       // Latent demand load [W]
+                bool const IsCallbyWH,         // whether the call from the water heating loop or air loop, true = from water heating loop
+                bool const FirstHVACIteration, // TRUE if First iteration of simulation
+                ObjexxFCL::Optional<Real64 const> OnOffAirFlowRat = _ // ratio of comp on to comp off air flow rate
+    );
+
     void GetIHPInput(EnergyPlusData &state);
 
     void SizeIHP(EnergyPlusData &state, int const CoilNum);
@@ -301,37 +314,53 @@ namespace IntegratedHeatPump {
 
     bool IHPInModel(EnergyPlusData &state);
 
-    int GetCoilIndexIHP(EnergyPlusData &state,
-                        std::string const &CoilType, // must match coil types in this module
-                        std::string const &CoilName, // must match coil names for the coil type
-                        bool &ErrorsFound            // set to true if problem
+    int GetIHPIndex(EnergyPlusData &state,
+                    std::string const &CoilType, // must match coil types in this module
+                    std::string const &CoilName, // must match coil names for the coil type
+                    bool &ErrorsFound            // set to true if problem
     );
 
-    int GetCoilInletNodeIHP(EnergyPlusData &state,
+    int GetIHPIndex(EnergyPlusData &state,
+                    std::string const &CoilName
+    );
+  
+    int GetIHPCoilAirInletNode(EnergyPlusData &state,
                             std::string const &CoilType, // must match coil types in this module
                             std::string const &CoilName, // must match coil names for the coil type
                             bool &ErrorsFound            // set to true if problem
     );
 
-    int GetDWHCoilInletNodeIHP(EnergyPlusData &state,
-                               std::string const &CoilType, // must match coil types in this module
-                               std::string const &CoilName, // must match coil names for the coil type
-                               bool &ErrorsFound            // set to true if problem
+    int GetIHPCoilAirInletNode(EnergyPlusData &state,
+                               int const ihpNum);
+  
+    int GetIHPDWHCoilAirInletNode(EnergyPlusData &state,
+                                  std::string const &CoilType, // must match coil types in this module
+                                  std::string const &CoilName, // must match coil names for the coil type
+                                  bool &ErrorsFound            // set to true if problem
     );
 
-    int GetDWHCoilOutletNodeIHP(EnergyPlusData &state,
-                                std::string const &CoilType, // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
+    int GetIHPDWHCoilAirInletNode(EnergyPlusData &state,
+                                  int const ihpNum);
+  
+    int GetIHPDWHCoilAirOutletNode(EnergyPlusData &state,
+                                   std::string const &CoilType, // must match coil types in this module
+                                   std::string const &CoilName, // must match coil names for the coil type
+                                   bool &ErrorsFound            // set to true if problem
     );
 
-    Real64 GetDWHCoilCapacityIHP(EnergyPlusData &state,
+    int GetIHPDWHCoilAirOutletNode(EnergyPlusData &state,
+                                   int const ihpNum);
+  
+    Real64 GetIHPDWHCoilCapacity(EnergyPlusData &state,
                                  std::string const &CoilType, // must match coil types in this module
                                  std::string const &CoilName, // must match coil names for the coil type
                                  IHPOperationMode const Mode, // mode coil type
                                  bool &ErrorsFound            // set to true if problem
     );
 
+    Real64 GetIHPDWHCoilCapacity(EnergyPlusData &state,
+                                 int const ihpNum);
+  
     int GetIHPDWHCoilPLFFPLR(EnergyPlusData &state,
                              std::string const &CoilType, // must match coil types in this module
                              std::string const &CoilName, // must match coil names for the coil type
@@ -339,6 +368,9 @@ namespace IntegratedHeatPump {
                              bool &ErrorsFound            // set to true if problem
     );
 
+    int GetIHPDWHCoilPLFFPLR(EnergyPlusData &state,
+                             int const ihpNum);
+  
     void ClearCoils(EnergyPlusData &state, int const DXCoilNum // coil ID
     );
 
diff --git a/src/EnergyPlus/MixedAir.cc b/src/EnergyPlus/MixedAir.cc
index 4bdfd8290bc..fc57fc3c033 100644
--- a/src/EnergyPlus/MixedAir.cc
+++ b/src/EnergyPlus/MixedAir.cc
@@ -426,7 +426,7 @@ void SimOutsideAirSys(EnergyPlusData &state, int const OASysNum, bool const Firs
 void SimOAComponent(EnergyPlusData &state,
                     std::string const &CompType,                    // the component type
                     std::string const &CompName,                    // the component Name
-                    SimAirServingZones::CompType const CompTypeNum, // Component Type -- Integerized for this module
+                    SimAirServingZones::CompType const compType, // Component Type -- Integerized for this module
                     bool const FirstHVACIteration,
                     int &CompIndex,
                     int const AirLoopNum, // air loop index for economizer lockout coordination
@@ -460,8 +460,8 @@ void SimOAComponent(EnergyPlusData &state,
     bool HeatingActive = false; // why isn't this returning that a coil is active?
     bool CoolingActive = false;
 
-    switch (CompTypeNum) {
-    case SimAirServingZones::CompType::OAMixer_Num: { // OutdoorAir:Mixer
+    switch (compType) {
+    case SimAirServingZones::CompType::OAMixer: { // OutdoorAir:Mixer
         if (Sim) {
             SimOAMixer(state, CompName, CompIndex);
         }
@@ -569,7 +569,7 @@ void SimOAComponent(EnergyPlusData &state,
         if (Sim) {
             // get water coil and controller data if not called previously
             if (CompIndex == 0)
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
+                HXAssistCoil::SimHXAssistedCoolingCoil(
                     state, CompName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, CompIndex, HVAC::FanOp::Continuous);
             // iterate on OA sys controller and water coil at the same time
             SimAirServingZones::SolveWaterCoilController(state,
@@ -577,11 +577,11 @@ void SimOAComponent(EnergyPlusData &state,
                                                          AirLoopNum,
                                                          CompName,
                                                          CompIndex,
-                                                         state.dataHVACAssistedCC->HXAssistedCoil(CompIndex).ControllerName,
-                                                         state.dataHVACAssistedCC->HXAssistedCoil(CompIndex).ControllerIndex,
+                                                         state.dataHVACAssistedCC->HXAssistedCoils(CompIndex).ControllerName,
+                                                         state.dataHVACAssistedCC->HXAssistedCoils(CompIndex).ControllerIndex,
                                                          true);
             // set flag to tell HVAC controller it will be simulated only in SolveWaterCoilController()
-            state.dataHVACControllers->ControllerProps(state.dataHVACAssistedCC->HXAssistedCoil(CompIndex).ControllerIndex).BypassControllerCalc =
+            state.dataHVACControllers->ControllerProps(state.dataHVACAssistedCC->HXAssistedCoils(CompIndex).ControllerIndex).BypassControllerCalc =
                 true;
         }
         OACoolingCoil = true;
@@ -605,7 +605,7 @@ void SimOAComponent(EnergyPlusData &state,
                                                                                       sensOut,
                                                                                       latOut);
         }
-        if (state.dataMixedAir->MyOneTimeCheckUnitarySysFlag(OASysNum) && CompTypeNum == SimAirServingZones::CompType::UnitarySystemModel) {
+        if (state.dataMixedAir->MyOneTimeCheckUnitarySysFlag(OASysNum) && compType == SimAirServingZones::CompType::UnitarySystemModel) {
             UnitarySystems::UnitarySys::getUnitarySysHeatCoolCoil(state, CompName, OACoolingCoil, OAHeatingCoil, 0);
             UnitarySystems::UnitarySys::checkUnitarySysCoilInOASysExists(state, CompName, 0);
             if (Sim) state.dataMixedAir->MyOneTimeCheckUnitarySysFlag(OASysNum) = false;
@@ -750,7 +750,14 @@ void SimOAMixer(EnergyPlusData &state, std::string const &CompName, int &CompInd
         OAMixerNum = CompIndex;
     }
 
-    auto &mixer = state.dataMixedAir->OAMixer(OAMixerNum);
+    SimOAMixer(state, OAMixerNum);
+}
+
+void SimOAMixer(EnergyPlusData &state, int const mixerNum)
+{
+    assert(mixerNum > 0 && mixerNum <= state.dataMixedAir->OAMixer.size());
+    
+    auto &mixer = state.dataMixedAir->OAMixer(mixerNum);
 
     mixer.InitOAMixer(state);
 
@@ -780,24 +787,22 @@ void SimOAController(EnergyPlusData &state, std::string const &CtrlName, int &Ct
 
     // check that the economizer staging operation EconomizerFirst is only used with an sensible load-based controlled AirLoopHVAC:UnitarySystem
     if (AirLoopNum > 0) {
-        auto &primaryAirSystems = state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum);
-        if (primaryAirSystems.EconomizerStagingCheckFlag == false) {
+        auto &airSys = state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum);
+        if (airSys.EconomizerStagingCheckFlag == false) {
             OAControllerNum = Util::FindItemInList(CtrlName, state.dataMixedAir->OAController);
             if (state.dataMixedAir->OAController(OAControllerNum).EconomizerStagingType == HVAC::EconomizerStagingType::EconomizerFirst) {
                 bool sensLoadCtrlUnitarySystemFound = false;
-                for (int BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
-                    for (int CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
-                        if (primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num == SimAirServingZones::CompType::UnitarySystemModel) {
-                            std::string_view unitarySystemName = primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name;
-                            int unitarySystemNum = Util::FindItemInList(
-                                unitarySystemName, state.dataUnitarySystems->unitarySys, state.dataUnitarySystems->numUnitarySystems);
-                            if (state.dataUnitarySystems->unitarySys[unitarySystemNum - 1].m_ControlType ==
-                                UnitarySystems::UnitarySys::UnitarySysCtrlType::Load) {
-                                if (state.dataUnitarySystems->unitarySys[unitarySystemNum - 1].m_CoolingCoilType_Num ==
-                                        HVAC::CoilDX_MultiSpeedCooling ||
-                                    state.dataUnitarySystems->unitarySys[unitarySystemNum - 1].m_CoolingCoilType_Num ==
-                                        HVAC::Coil_CoolingAirToAirVariableSpeed ||
-                                    state.dataUnitarySystems->unitarySys[unitarySystemNum - 1].m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+                for (int BranchNum = 1; BranchNum <= airSys.NumBranches; ++BranchNum) {
+                    auto const &branch = airSys.Branch(BranchNum);
+                    for (int CompNum = 1; CompNum <= branch.TotalComponents; ++CompNum) {
+                        auto const &comp = branch.Comp(CompNum);
+                        if (comp.compType == SimAirServingZones::CompType::UnitarySystemModel) {
+                            int unitSysNum = UnitarySystems::getUnitarySystemIndex(state, comp.Name);
+                            auto const &unitSys = state.dataUnitarySystems->unitarySys[unitSysNum]; 
+                            if (unitSys.m_ControlType == UnitarySystems::UnitarySys::UnitarySysCtrlType::Load) {
+                                if (unitSys.m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                                    unitSys.m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                                    unitSys.m_coolCoilType == HVAC::CoilType::CoolingDX) {
                                     sensLoadCtrlUnitarySystemFound = true;
                                     break;
                                 }
@@ -816,7 +821,7 @@ void SimOAController(EnergyPlusData &state, std::string const &CtrlName, int &Ct
                             state.dataMixedAir->OAController(OAControllerNum).Name));
                 }
             }
-            primaryAirSystems.EconomizerStagingCheckFlag = true;
+            airSys.EconomizerStagingCheckFlag = true;
         }
     }
 
@@ -4788,19 +4793,23 @@ void OAControllerProps::SizeOAController(EnergyPlusData &state)
         for (int CompNum = 1; CompNum <= state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).NumComponents; ++CompNum) {
             std::string const &CompType = state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).ComponentType(CompNum);
             std::string const &CompName = state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).ComponentName(CompNum);
-            if (Util::SameString(CompType, "COIL:COOLING:WATER:DETAILEDGEOMETRY") || Util::SameString(CompType, "COIL:HEATING:WATER") ||
-                Util::SameString(CompType, "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED")) {
-                std::string CoilName;
-                std::string CoilType;
-
-                if (Util::SameString(CompType, "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED")) {
-                    CoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, CompType, CompName, ErrorsFound);
-                    CoilType = HVACHXAssistedCoolingCoil::GetHXCoilType(state, CompType, CompName, ErrorsFound);
+            if (Util::SameString(CompType, "COIL:COOLING:WATER:DETAILEDGEOMETRY") || 
+                Util::SameString(CompType, "COIL:HEATING:WATER")) {
+                int waterCoilNum = WaterCoils::GetCoilIndex(state, CompName);
+                if (waterCoilNum == 0) {
+                    ShowSevereError(state, format("Item not found: {} = \"{}\"", CompType, CompName));
+                    ErrorsFound = true;
+                } else {
+                    WaterCoils::SetCoilDesFlow(state, waterCoilNum, this->MinOA);
+                }
+            } else if (Util::SameString(CompType, "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED")) {
+                int hxCoilNum = HXAssistCoil::GetCoilIndex(state, CompName);
+                if (hxCoilNum == 0) {
+                    ShowSevereError(state, format("Item not found: {} = \"{}\"", CompType, CompName));
+                    ErrorsFound = true;
                 } else {
-                    CoilName = CompName;
-                    CoilType = CompType;
+                    WaterCoils::SetCoilDesFlow(state, HXAssistCoil::GetCoilChildCoilIndex(state, hxCoilNum), this->MinOA);
                 }
-                WaterCoils::SetCoilDesFlow(state, CoilType, CoilName, this->MinOA, ErrorsFound);
             }
         } // End of component loop
     }
diff --git a/src/EnergyPlus/MixedAir.hh b/src/EnergyPlus/MixedAir.hh
index 5af6484583c..ed060b1e2e3 100644
--- a/src/EnergyPlus/MixedAir.hh
+++ b/src/EnergyPlus/MixedAir.hh
@@ -386,6 +386,8 @@ namespace MixedAir {
 
     void SimOAMixer(EnergyPlusData &state, std::string const &CompName, int &CompIndex);
 
+    void SimOAMixer(EnergyPlusData &state, int const mixerNum);
+
     void SimOAController(EnergyPlusData &state, std::string const &CtrlName, int &CtrlIndex, bool FirstHVACIteration, int AirLoopNum);
 
     void GetOutsideAirSysInputs(EnergyPlusData &state);
diff --git a/src/EnergyPlus/OutdoorAirUnit.cc b/src/EnergyPlus/OutdoorAirUnit.cc
index 281170ba70a..29b8fbd4d6a 100644
--- a/src/EnergyPlus/OutdoorAirUnit.cc
+++ b/src/EnergyPlus/OutdoorAirUnit.cc
@@ -217,19 +217,8 @@ namespace OutdoorAirUnit {
         using BranchNodeConnections::SetUpCompSets;
         using BranchNodeConnections::TestCompSet;
         using NodeInputManager::GetOnlySingleNode;
-        using SteamCoils::GetCoilAirInletNode;
-        using SteamCoils::GetCoilAirOutletNode;
-        using SteamCoils::GetCoilMaxSteamFlowRate;
-        using SteamCoils::GetCoilSteamInletNode;
-        using SteamCoils::GetCoilSteamOutletNode;
-        using SteamCoils::GetSteamCoilIndex;
         using namespace DataLoopNode;
-        using HeatingCoils::GetCoilInletNode;
-        using HeatingCoils::GetCoilOutletNode;
         using OutAirNodeManager::CheckAndAddAirNodeNumber;
-        using WaterCoils::GetCoilWaterInletNode;
-        using WaterCoils::GetCoilWaterOutletNode;
-        using WaterCoils::GetWaterCoilIndex;
 
         // SUBROUTINE PARAMETER DEFINITIONS:
         static constexpr std::string_view RoutineName("GetOutdoorAirUnitInputs: "); // include trailing blank space
@@ -578,206 +567,115 @@ namespace OutdoorAirUnit {
 
                     // Get information of component
                     for (int InListNum = 1; InListNum <= NumInList; ++InListNum) {
-                        thisOutAirUnit.OAEquip(InListNum).ComponentName = AlphArray(InListNum * 2 + 1);
-
-                        thisOutAirUnit.OAEquip(InListNum).Type =
-                            static_cast<CompType>(getEnumValue(CompTypeNamesUC, Util::makeUPPER(AlphArray(InListNum * 2))));
+                        auto &oaEquip = thisOutAirUnit.OAEquip(InListNum);
+                        oaEquip.ComponentName = AlphArray(InListNum * 2 + 1);
+                        oaEquip.Type = static_cast<CompType>(getEnumValue(CompTypeNamesUC, AlphArray(InListNum * 2)));
 
                         int const CompNum = InListNum;
-
+                        
                         // Coil Types
-                        switch (thisOutAirUnit.OAEquip(InListNum).Type) {
+                        switch (oaEquip.Type) {
                         case CompType::WaterCoil_Cooling: {
-                            thisOutAirUnit.OAEquip(CompNum).CoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                            thisOutAirUnit.OAEquip(CompNum).ComponentIndex =
-                                GetWaterCoilIndex(state,
-                                                  CompTypeNamesUC[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                  thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                  ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirInletNode =
-                                WaterCoils::GetCoilInletNode(state,
-                                                             CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                             thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                             ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirOutletNode =
-                                WaterCoils::GetCoilOutletNode(state,
-                                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                              thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                              ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterInletNode =
-                                GetCoilWaterInletNode(state,
-                                                      CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                      thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                      ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterOutletNode =
-                                GetCoilWaterOutletNode(state,
-                                                       CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                       thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                       ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MaxVolWaterFlow =
-                                WaterCoils::GetCoilMaxWaterFlowRate(state,
-                                                                    CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                                    thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                                    ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MinVolWaterFlow = 0.0;
-                            break;
-                        }
+                            oaEquip.CoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+                            oaEquip.ComponentIndex = WaterCoils::GetCoilIndex(state, oaEquip.ComponentName);
+                            if (oaEquip.ComponentIndex == 0) {
+                                ShowSevereItemNotFound(state, eoh, cAlphaFields(InListNum * 2 + 1), oaEquip.ComponentName);
+                                ErrorsFound = true;
+                            } else {
+                                oaEquip.CoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.MaxVolWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, oaEquip.ComponentIndex);
+                                oaEquip.MinVolWaterFlow = 0.0;
+                            } 
+                        } break;
+
                         case CompType::WaterCoil_SimpleHeat: {
-                            thisOutAirUnit.OAEquip(CompNum).CoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-                            thisOutAirUnit.OAEquip(CompNum).ComponentIndex =
-                                GetWaterCoilIndex(state,
-                                                  CompTypeNamesUC[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                  thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                  ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirInletNode =
-                                WaterCoils::GetCoilInletNode(state,
-                                                             CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                             thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                             ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirOutletNode = WaterCoils::GetCoilOutletNode(
-                                state, "Coil:Heating:Water", thisOutAirUnit.OAEquip(CompNum).ComponentName, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterInletNode =
-                                GetCoilWaterInletNode(state,
-                                                      CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                      thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                      ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterOutletNode =
-                                GetCoilWaterOutletNode(state,
-                                                       CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                       thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                       ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MaxVolWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(
-                                state, "Coil:Heating:Water", thisOutAirUnit.OAEquip(CompNum).ComponentName, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MinVolWaterFlow = 0.0;
-                            break;
-                        }
+                            oaEquip.CoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+                            oaEquip.ComponentIndex = WaterCoils::GetCoilIndex(state, oaEquip.ComponentName);
+                            if (oaEquip.ComponentIndex == 0) {
+                                ShowSevereItemNotFound(state, eoh, cAlphaFields(InListNum * 2 + 1), oaEquip.ComponentName);
+                                ErrorsFound = true;
+                            } else {
+                                oaEquip.CoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.MaxVolWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, oaEquip.ComponentIndex);
+                                oaEquip.MinVolWaterFlow = 0.0;
+                            }
+                        } break;
+                          
                         case CompType::SteamCoil_AirHeat: {
-                            thisOutAirUnit.OAEquip(CompNum).CoilType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-                            thisOutAirUnit.OAEquip(CompNum).ComponentIndex =
-                                GetSteamCoilIndex(state,
-                                                  CompTypeNamesUC[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                  thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                  ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirInletNode = GetCoilAirInletNode(
-                                state, thisOutAirUnit.OAEquip(CompNum).ComponentIndex, thisOutAirUnit.OAEquip(CompNum).ComponentName, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirOutletNode = GetCoilAirOutletNode(
-                                state, thisOutAirUnit.OAEquip(CompNum).ComponentIndex, thisOutAirUnit.OAEquip(CompNum).ComponentName, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterInletNode = GetCoilSteamInletNode(
-                                state, thisOutAirUnit.OAEquip(CompNum).ComponentIndex, thisOutAirUnit.OAEquip(CompNum).ComponentName, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterOutletNode =
-                                GetCoilSteamOutletNode(state,
-                                                       CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                       thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                       ErrorsFound);
-
-                            thisOutAirUnit.OAEquip(CompNum).MaxVolWaterFlow =
-                                GetCoilMaxSteamFlowRate(state, thisOutAirUnit.OAEquip(CompNum).ComponentIndex, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MinVolWaterFlow = 0.0;
-                            // below: no extra error needed if steam properties not in input
-                            // file because getting the steam coil will have done that.
-                            thisOutAirUnit.OAEquip(CompNum).FluidIndex = Fluid::GetRefrigNum(state, "STEAM");
-                            break;
-                        }
+                            oaEquip.CoilType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+                            oaEquip.ComponentIndex = SteamCoils::GetCoilIndex(state, oaEquip.ComponentName);
+                            if (oaEquip.ComponentIndex == 0) {
+                                ShowSevereItemNotFound(state, eoh, cAlphaFields(InListNum * 2 + 1), oaEquip.ComponentName);
+                                ErrorsFound = true;
+                            } else {
+                                oaEquip.CoilAirInletNode = SteamCoils::GetCoilAirInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterInletNode = SteamCoils::GetCoilSteamInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterOutletNode = SteamCoils::GetCoilSteamOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.MaxVolWaterFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, oaEquip.ComponentIndex);
+                                oaEquip.MinVolWaterFlow = 0.0;
+                                // below: no extra error needed if steam properties not in input
+                                // file because getting the steam coil will have done that.
+                                oaEquip.FluidIndex = Fluid::GetRefrigNum(state, "STEAM");
+                            }
+                        } break;
+                          
                         case CompType::WaterCoil_DetailedCool: {
-                            thisOutAirUnit.OAEquip(CompNum).ComponentIndex =
-                                GetWaterCoilIndex(state,
-                                                  CompTypeNamesUC[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                  thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                  ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirInletNode =
-                                WaterCoils::GetCoilInletNode(state,
-                                                             CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                             thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                             ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirOutletNode =
-                                WaterCoils::GetCoilOutletNode(state,
-                                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                              thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                              ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterInletNode =
-                                GetCoilWaterInletNode(state,
-                                                      CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                      thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                      ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterOutletNode =
-                                GetCoilWaterOutletNode(state,
-                                                       CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                       thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                       ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MaxVolWaterFlow =
-                                WaterCoils::GetCoilMaxWaterFlowRate(state,
-                                                                    CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                                    thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                                    ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MinVolWaterFlow = 0.0;
-                            break;
-                        }
+                            oaEquip.CoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+                            oaEquip.ComponentIndex = WaterCoils::GetCoilIndex(state, oaEquip.ComponentName);
+                            if (oaEquip.ComponentIndex == 0) {
+                                ShowSevereItemNotFound(state, eoh, cAlphaFields(InListNum * 2 + 1), oaEquip.ComponentName);
+                                ErrorsFound = true;
+                            } else {
+                                oaEquip.CoilAirInletNode = WaterCoils::GetCoilAirInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.MaxVolWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, oaEquip.ComponentIndex);
+                                oaEquip.MinVolWaterFlow = 0.0;
+                            }
+                        } break;
+                          
                         case CompType::WaterCoil_CoolingHXAsst: {
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirInletNode =
-                                HVACHXAssistedCoolingCoil::GetCoilInletNode(state,
-                                                                            CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                                            thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                                            ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirOutletNode =
-                                HVACHXAssistedCoolingCoil::GetCoilOutletNode(state,
-                                                                             CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                                             thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                                             ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterInletNode =
-                                GetCoilWaterInletNode(state,
-                                                      CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                      thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                      ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilWaterOutletNode =
-                                GetCoilWaterOutletNode(state,
-                                                       CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                       thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                       ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MaxVolWaterFlow = HVACHXAssistedCoolingCoil::GetCoilMaxWaterFlowRate(
-                                state,
-                                CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).MinVolWaterFlow = 0.0;
-                            break;
-                        }
-                        case CompType::Coil_ElectricHeat: {
-                            // Get OutAirUnit( OAUnitNum ).OAEquip( CompNum ).ComponentIndex, 2 types of mining functions to choose from
-                            HeatingCoils::GetCoilIndex(
-                                state, thisOutAirUnit.OAEquip(CompNum).ComponentName, thisOutAirUnit.OAEquip(CompNum).ComponentIndex, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirInletNode =
-                                HeatingCoils::GetCoilInletNode(state,
-                                                               CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                               thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                               ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirOutletNode =
-                                HeatingCoils::GetCoilOutletNode(state,
-                                                                CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                                thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                                ErrorsFound);
-                            break;
-                        }
+                            // Does this not have a PlantEquipmentType?
+                            oaEquip.ComponentIndex = HXAssistCoil::GetCoilIndex(state, oaEquip.ComponentName);
+                            if (oaEquip.ComponentIndex == 0) {
+                                ShowSevereItemNotFound(state, eoh, cAlphaFields(InListNum * 2 + 1), oaEquip.ComponentName);
+                                ErrorsFound = true;
+                            } else {
+                                // Should this be the index of the child coil or the parent HXAssisted Coil?
+                                oaEquip.CoilAirInletNode = HXAssistCoil::GetCoilAirInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilAirOutletNode = HXAssistCoil::GetCoilAirOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterInletNode = HXAssistCoil::GetCoilWaterInletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.CoilWaterOutletNode = HXAssistCoil::GetCoilWaterOutletNode(state, oaEquip.ComponentIndex);
+                                oaEquip.MaxVolWaterFlow = HXAssistCoil::GetCoilMaxWaterFlowRate(state, oaEquip.ComponentIndex);
+                                oaEquip.MinVolWaterFlow = 0.0;
+                            }
+                        } break;
+                          
+                        case CompType::Coil_ElectricHeat:
                         case CompType::Coil_GasHeat: {
                             // Get OutAirUnit( OAUnitNum ).OAEquip( CompNum ).ComponentIndex, 2 types of mining functions to choose from
-                            HeatingCoils::GetCoilIndex(
-                                state, thisOutAirUnit.OAEquip(CompNum).ComponentName, thisOutAirUnit.OAEquip(CompNum).ComponentIndex, ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirInletNode =
-                                GetCoilInletNode(state,
-                                                 CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                 thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                 ErrorsFound);
-                            thisOutAirUnit.OAEquip(CompNum).CoilAirOutletNode =
-                                GetCoilOutletNode(state,
-                                                  CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)],
-                                                  thisOutAirUnit.OAEquip(CompNum).ComponentName,
-                                                  ErrorsFound);
-                            break;
-                        }
+                            oaEquip.ComponentIndex = HeatingCoils::GetCoilIndex(state, oaEquip.ComponentName);
+                            if (oaEquip.ComponentIndex == 0) {
+                                ShowSevereItemNotFound(state, eoh, cAlphaFields(InListNum * 2 + 1), oaEquip.ComponentName);
+                                ErrorsFound = true;
+                            } else {
+                               oaEquip.CoilAirInletNode = HeatingCoils::GetCoilAirInletNode(state, oaEquip.ComponentIndex);
+                               oaEquip.CoilAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, oaEquip.ComponentIndex);
+                            }
+                        } break;
+                            
                         case CompType::DXSystem: {
                             // set the data for 100% DOAS DX cooling coil
                             // is a different function call needed here? similar to one in HVACDXSystem
-                            // CheckDXCoolingCoilInOASysExists(state, thisOutAirUnit.OAEquip(CompNum).ComponentName);
+                            // CheckDXCoolingCoilInOASysExists(state, oaEquip.ComponentName);
                             break;
                         }
                         case CompType::DXHeatPumpSystem: {
@@ -785,10 +683,10 @@ namespace OutdoorAirUnit {
                         }
                         case CompType::UnitarySystemModel: {
                             UnitarySystems::UnitarySys thisSys;
-                            thisOutAirUnit.OAEquip(CompNum).compPointer = thisSys.factory(
-                                state, HVAC::UnitarySysType::Unitary_AnyCoilType, thisOutAirUnit.OAEquip(CompNum).ComponentName, false, OAUnitNum);
+                            oaEquip.compPointer = thisSys.factory(
+                                state, HVAC::UnitarySysType::Unitary_AnyCoilType, oaEquip.ComponentName, false, OAUnitNum);
                             UnitarySystems::UnitarySys::checkUnitarySysCoilInOASysExists(
-                                state, thisOutAirUnit.OAEquip(CompNum).ComponentName, OAUnitNum);
+                                state, oaEquip.ComponentName, OAUnitNum);
 
                             // Heat recovery
                             break;
@@ -808,11 +706,7 @@ namespace OutdoorAirUnit {
                             break;
                         }
                         default: {
-                            ShowSevereError(state,
-                                            format("{}= \"{}\" invalid Outside Air Component=\"{}\".",
-                                                   CurrentModuleObject,
-                                                   AlphArray(1),
-                                                   CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(CompNum).Type)]));
+                            ShowSevereInvalidKey(state, eoh, cAlphaFields(InListNum * 2), state.dataIPShortCut->cAlphaArgs(InListNum * 2));
                             ErrorsFound = true;
                         }
                         }
@@ -824,24 +718,24 @@ namespace OutdoorAirUnit {
                                 SetUpCompSets(state,
                                               "ZoneHVAC:OutdoorAirUnit",
                                               thisOutAirUnit.Name,
-                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(InListNum).Type)],
-                                              thisOutAirUnit.OAEquip(InListNum).ComponentName,
+                                              CompTypeNames[(int)oaEquip.Type],
+                                              oaEquip.ComponentName,
                                               state.dataIPShortCut->cAlphaArgs(15),
                                               "UNDEFINED");
                             } else if (InListNum != NumInList) { // the component is placed in b/w components
                                 SetUpCompSets(state,
                                               "ZoneHVAC:OutdoorAirUnit",
                                               thisOutAirUnit.Name,
-                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(InListNum).Type)],
-                                              thisOutAirUnit.OAEquip(InListNum).ComponentName,
+                                              CompTypeNames[(int)oaEquip.Type],
+                                              oaEquip.ComponentName,
                                               "UNDEFINED",
                                               "UNDEFINED");
                             } else { // (InListNum == NumInList) => the component is the last one
                                 SetUpCompSets(state,
                                               "ZoneHVAC:OutdoorAirUnit",
                                               thisOutAirUnit.Name,
-                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(InListNum).Type)],
-                                              thisOutAirUnit.OAEquip(InListNum).ComponentName,
+                                              CompTypeNames[(int)oaEquip.Type],
+                                              oaEquip.ComponentName,
                                               "UNDEFINED",
                                               state.dataIPShortCut->cAlphaArgs(13));
                             }
@@ -851,32 +745,31 @@ namespace OutdoorAirUnit {
                                 SetUpCompSets(state,
                                               "ZoneHVAC:OutdoorAirUnit",
                                               thisOutAirUnit.Name,
-                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(InListNum).Type)],
-                                              thisOutAirUnit.OAEquip(InListNum).ComponentName,
+                                              CompTypeNames[(int)oaEquip.Type],
+                                              oaEquip.ComponentName,
                                               state.dataIPShortCut->cAlphaArgs(12),
                                               "UNDEFINED");
                             } else if (InListNum != NumInList) {
                                 SetUpCompSets(state,
                                               "ZoneHVAC:OutdoorAirUnit",
                                               thisOutAirUnit.Name,
-                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(InListNum).Type)],
-                                              thisOutAirUnit.OAEquip(InListNum).ComponentName,
+                                              CompTypeNames[(int)oaEquip.Type],
+                                              oaEquip.ComponentName,
                                               "UNDEFINED",
                                               "UNDEFINED");
                             } else { // (InListNum == NumInList) => the component is the last one
                                 SetUpCompSets(state,
                                               "ZoneHVAC:OutdoorAirUnit",
                                               thisOutAirUnit.Name,
-                                              CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(InListNum).Type)],
-                                              thisOutAirUnit.OAEquip(InListNum).ComponentName,
+                                              CompTypeNames[(int)oaEquip.Type],
+                                              oaEquip.ComponentName,
                                               "UNDEFINED",
                                               "UNDEFINED");
                             }
                         }
                         // Must call after SetUpCompSets since this will add another CoilSystem:Cooling:DX object in CompSets
-                        if (CompTypeNamesUC[static_cast<int>(thisOutAirUnit.OAEquip(InListNum).Type)] == "COILSYSTEM:COOLING:DX") {
-                            UnitarySystems::UnitarySys::checkUnitarySysCoilInOASysExists(
-                                state, thisOutAirUnit.OAEquip(CompNum).ComponentName, OAUnitNum);
+                        if (CompTypeNamesUC[(int)oaEquip.Type] == "COILSYSTEM:COOLING:DX") { // Why not compare the types?
+                            UnitarySystems::UnitarySys::checkUnitarySysCoilInOASysExists(state, oaEquip.ComponentName, OAUnitNum);
                         }
                     } // End Inlist
 
@@ -1072,7 +965,6 @@ namespace OutdoorAirUnit {
 
         // Using/Aliasing
         using DataZoneEquipment::CheckZoneEquipmentList;
-        using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil;
         using PlantUtilities::InitComponentNodes;
         using PlantUtilities::ScanPlantLoopsForObject;
         using SteamCoils::GetCoilMaxSteamFlowRate;
@@ -1196,68 +1088,55 @@ namespace OutdoorAirUnit {
             if (!state.dataOutdoorAirUnit->MyPlantScanFlag(OAUnitNum)) {
                 bool errFlag = false;
                 for (int compLoop = 1; compLoop <= thisOutAirUnit.NumComponents; ++compLoop) {
-                    if ((thisOutAirUnit.OAEquip(compLoop).Type == CompType::WaterCoil_Cooling) ||
-                        (thisOutAirUnit.OAEquip(compLoop).Type == CompType::WaterCoil_DetailedCool)) {
-                        thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state,
-                                                                CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(compLoop).Type)],
-                                                                thisOutAirUnit.OAEquip(compLoop).ComponentName,
-                                                                errFlag);
-                        Real64 const rho = state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum)
+                    auto &oaEquip = thisOutAirUnit.OAEquip(compLoop);
+                    if (oaEquip.Type == CompType::WaterCoil_Cooling ||
+                        oaEquip.Type == CompType::WaterCoil_DetailedCool) {
+                        oaEquip.MaxVolWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, oaEquip.ComponentIndex);
+                        Real64 const rho = state.dataPlnt->PlantLoop(oaEquip.plantLoc.loopNum)
                                                .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName);
-                        thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow;
-                        thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MinVolWaterFlow;
+                        oaEquip.MaxWaterMassFlow = rho * oaEquip.MaxVolWaterFlow;
+                        oaEquip.MinWaterMassFlow = rho * oaEquip.MinVolWaterFlow;
                         InitComponentNodes(state,
-                                           thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterInletNode,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterOutletNode);
-                    }
-
-                    if (thisOutAirUnit.OAEquip(compLoop).Type == CompType::WaterCoil_SimpleHeat) {
-                        thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state,
-                                                                CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(compLoop).Type)],
-                                                                thisOutAirUnit.OAEquip(compLoop).ComponentName,
-                                                                errFlag);
-                        Real64 const rho = state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum)
+                                           oaEquip.MinWaterMassFlow,
+                                           oaEquip.MaxWaterMassFlow,
+                                           oaEquip.CoilWaterInletNode,
+                                           oaEquip.CoilWaterOutletNode);
+
+                    } else if (oaEquip.Type == CompType::WaterCoil_SimpleHeat) {
+                        oaEquip.MaxVolWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, oaEquip.ComponentIndex);
+                        Real64 const rho = state.dataPlnt->PlantLoop(oaEquip.plantLoc.loopNum)
                                                .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                        thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow;
-                        thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MinVolWaterFlow;
+                        oaEquip.MaxWaterMassFlow = rho * oaEquip.MaxVolWaterFlow;
+                        oaEquip.MinWaterMassFlow = rho * oaEquip.MinVolWaterFlow;
                         InitComponentNodes(state,
-                                           thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterInletNode,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterOutletNode);
-                    }
-                    if (thisOutAirUnit.OAEquip(compLoop).Type == CompType::SteamCoil_AirHeat) {
-                        thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow =
-                            GetCoilMaxSteamFlowRate(state, thisOutAirUnit.OAEquip(compLoop).ComponentIndex, errFlag);
-                        Real64 const rho = state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum)
+                                           oaEquip.MinWaterMassFlow,
+                                           oaEquip.MaxWaterMassFlow,
+                                           oaEquip.CoilWaterInletNode,
+                                           oaEquip.CoilWaterOutletNode);
+
+                    } else if (oaEquip.Type == CompType::SteamCoil_AirHeat) {
+                        oaEquip.MaxVolWaterFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, oaEquip.ComponentIndex);
+                        Real64 const rho = state.dataPlnt->PlantLoop(oaEquip.plantLoc.loopNum)
                                                .steam->getSatDensity(state, Constant::SteamInitConvTemp, 1.0, RoutineName);
-                        thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow;
-                        thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MinVolWaterFlow;
+                        oaEquip.MaxWaterMassFlow = rho * oaEquip.MaxVolWaterFlow;
+                        oaEquip.MinWaterMassFlow = rho * oaEquip.MinVolWaterFlow;
                         InitComponentNodes(state,
-                                           thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterInletNode,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterOutletNode);
-                    }
-                    if (thisOutAirUnit.OAEquip(compLoop).Type == CompType::WaterCoil_CoolingHXAsst) {
-                        thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state,
-                                                                CompTypeNames[static_cast<int>(thisOutAirUnit.OAEquip(compLoop).Type)],
-                                                                thisOutAirUnit.OAEquip(compLoop).ComponentName,
-                                                                errFlag);
-                        Real64 const rho = state.dataPlnt->PlantLoop(thisOutAirUnit.OAEquip(compLoop).plantLoc.loopNum)
+                                           oaEquip.MinWaterMassFlow,
+                                           oaEquip.MaxWaterMassFlow,
+                                           oaEquip.CoilWaterInletNode,
+                                           oaEquip.CoilWaterOutletNode);
+
+                    } else if (oaEquip.Type == CompType::WaterCoil_CoolingHXAsst) {
+                        oaEquip.MaxVolWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, oaEquip.ComponentIndex);
+                        Real64 const rho = state.dataPlnt->PlantLoop(oaEquip.plantLoc.loopNum)
                                                .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName);
-                        thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MaxVolWaterFlow;
-                        thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow = rho * thisOutAirUnit.OAEquip(compLoop).MinVolWaterFlow;
+                        oaEquip.MaxWaterMassFlow = rho * oaEquip.MaxVolWaterFlow;
+                        oaEquip.MinWaterMassFlow = rho * oaEquip.MinVolWaterFlow;
                         InitComponentNodes(state,
-                                           thisOutAirUnit.OAEquip(compLoop).MinWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).MaxWaterMassFlow,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterInletNode,
-                                           thisOutAirUnit.OAEquip(compLoop).CoilWaterOutletNode);
+                                           oaEquip.MinWaterMassFlow,
+                                           oaEquip.MaxWaterMassFlow,
+                                           oaEquip.CoilWaterInletNode,
+                                           oaEquip.CoilWaterOutletNode);
                     }
                 }
             }
@@ -1354,7 +1233,6 @@ namespace OutdoorAirUnit {
         // Using/Aliasing
         using namespace DataSizing;
 
-        using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil;
         using PlantUtilities::MyPlantSizingIndex;
         using SteamCoils::SimulateSteamCoilComponents;
         using WaterCoils::SimulateWaterCoilComponents;
@@ -1493,7 +1371,7 @@ namespace OutdoorAirUnit {
             }
             if (thisOAEquip.Type == CompType::WaterCoil_CoolingHXAsst) {
                 if (thisOAEquip.MaxVolWaterFlow == AutoSize) {
-                    SimHXAssistedCoolingCoil(
+                  HXAssistCoil::SimHXAssistedCoolingCoil(
                         state, thisOAEquip.ComponentName, true, HVAC::CompressorOp::On, 0.0, thisOAEquip.ComponentIndex, HVAC::FanOp::Continuous);
                 }
             }
@@ -1542,9 +1420,6 @@ namespace OutdoorAirUnit {
 
         auto &TurnFansOff = state.dataHVACGlobal->TurnFansOff;
         auto &TurnFansOn = state.dataHVACGlobal->TurnFansOn;
-        using HeatingCoils::CheckHeatingCoilSchedule;
-        using HVACHXAssistedCoolingCoil::CheckHXAssistedCoolingCoilSchedule;
-
         // Locals
 
         // SUBROUTINE ARGUMENT DEFINITIONS:
@@ -1852,7 +1727,6 @@ namespace OutdoorAirUnit {
         using HeatRecovery::SimHeatRecovery;
         using HVAC::SmallLoad;
         using HVACDXHeatPumpSystem::SimDXHeatPumpSystem;
-        using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil;
         using WaterCoils::SimulateWaterCoilComponents;
 
         // SUBROUTINE LOCAL VARIABLE DEFINITIONS
@@ -2052,6 +1926,7 @@ namespace OutdoorAirUnit {
                                       thisOAEquip.plantLoc);
                 }
             } break;
+              
             case CompType::WaterCoil_CoolingHXAsst: { // 'CoilSystem:Cooling:Water:HeatExchangerAssisted'
                 if (Sim) {
                     int const ControlNode = thisOAEquip.CoilWaterInletNode;
@@ -2198,7 +2073,6 @@ namespace OutdoorAirUnit {
 
         // Using/Aliasing
         using HVAC::SmallLoad;
-        using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil;
         using SteamCoils::SimulateSteamCoilComponents;
         using WaterCoils::SimulateWaterCoilComponents;
 
@@ -2273,8 +2147,9 @@ namespace OutdoorAirUnit {
             LoadMet = AirMassFlow * (PsyHFnTdbW(oaOutletNode.Temp, oaInletNode.HumRat) - PsyHFnTdbW(oaInletNode.Temp, oaInletNode.HumRat));
 
         } break;
+          
         case CompType::WaterCoil_CoolingHXAsst: {
-            SimHXAssistedCoolingCoil(
+            HXAssistCoil::SimHXAssistedCoolingCoil(
                 state, thisOAEquip.ComponentName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, CoilIndex, HVAC::FanOp::Continuous);
             Real64 const AirMassFlow = oaInletNode.MassFlowRate;
             LoadMet = AirMassFlow * (PsyHFnTdbW(oaOutletNode.Temp, oaInletNode.HumRat) - PsyHFnTdbW(oaInletNode.Temp, oaInletNode.HumRat));
diff --git a/src/EnergyPlus/OutputReportTabular.cc b/src/EnergyPlus/OutputReportTabular.cc
index 0eeb6697b88..9b6b17eaf86 100644
--- a/src/EnergyPlus/OutputReportTabular.cc
+++ b/src/EnergyPlus/OutputReportTabular.cc
@@ -4348,31 +4348,34 @@ void CalcHeatEmissionReport(EnergyPlusData &state)
 
     // DX Coils air to air
     for (int iCoil = 1; iCoil <= state.dataDXCoils->NumDXCoils; ++iCoil) {
-        auto const &thisDXCoil = state.dataDXCoils->DXCoil(iCoil);
+        auto const &dxCoil = state.dataDXCoils->DXCoil(iCoil);
 
-        if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-            thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedCooling || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-            if (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Air) {
-                state.dataHeatBal->SysTotalHVACRejectHeatLoss += thisDXCoil.ElecCoolingConsumption + thisDXCoil.DefrostConsumption +
-                                                                 thisDXCoil.CrankcaseHeaterConsumption + thisDXCoil.TotalCoolingEnergy;
-            } else if (thisDXCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap) {
-                state.dataHeatBal->SysTotalHVACRejectHeatLoss += thisDXCoil.EvapCondPumpElecConsumption + thisDXCoil.BasinHeaterConsumption +
-                                                                 thisDXCoil.EvapWaterConsump * RhoWater * H2OHtOfVap_HVAC;
+        if (dxCoil.coilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+            dxCoil.coilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+            dxCoil.coilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+            dxCoil.coilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+            if (dxCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Air) {
+                state.dataHeatBal->SysTotalHVACRejectHeatLoss += dxCoil.ElecCoolingConsumption + dxCoil.DefrostConsumption +
+                                                                 dxCoil.CrankcaseHeaterConsumption + dxCoil.TotalCoolingEnergy;
+            } else if (dxCoil.CondenserType(1) == DataHeatBalance::RefrigCondenserType::Evap) {
+                state.dataHeatBal->SysTotalHVACRejectHeatLoss += dxCoil.EvapCondPumpElecConsumption + dxCoil.BasinHeaterConsumption +
+                                                                 dxCoil.EvapWaterConsump * RhoWater * H2OHtOfVap_HVAC;
             }
-            if (thisDXCoil.FuelType != Constant::eFuel::Electricity) {
-                state.dataHeatBal->SysTotalHVACRejectHeatLoss += thisDXCoil.MSFuelWasteHeat * TimeStepSysSec;
+            if (dxCoil.FuelType != Constant::eFuel::Electricity) {
+                state.dataHeatBal->SysTotalHVACRejectHeatLoss += dxCoil.MSFuelWasteHeat * TimeStepSysSec;
             }
-        } else if (thisDXCoil.DXCoilType_Num == HVAC::CoilDX_HeatingEmpirical || thisDXCoil.DXCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
-            state.dataHeatBal->SysTotalHVACRejectHeatLoss += thisDXCoil.ElecHeatingConsumption + thisDXCoil.DefrostConsumption +
-                                                             thisDXCoil.FuelConsumed + thisDXCoil.CrankcaseHeaterConsumption -
-                                                             thisDXCoil.TotalHeatingEnergy;
+        } else if (dxCoil.coilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+                   dxCoil.coilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+            state.dataHeatBal->SysTotalHVACRejectHeatLoss += dxCoil.ElecHeatingConsumption + dxCoil.DefrostConsumption +
+                                                             dxCoil.FuelConsumed + dxCoil.CrankcaseHeaterConsumption -
+                                                             dxCoil.TotalHeatingEnergy;
         }
     }
     // VAV coils - air to air
     for (int iCoil = 1; iCoil <= state.dataVariableSpeedCoils->NumVarSpeedCoils; ++iCoil) {
         auto const &thisCoil = state.dataVariableSpeedCoils->VarSpeedCoil(iCoil);
 
-        if (thisCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+        if (thisCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
             if (thisCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
                 state.dataHeatBal->SysTotalHVACRejectHeatLoss +=
                     thisCoil.Energy + thisCoil.CrankcaseHeaterConsumption + thisCoil.DefrostConsumption + thisCoil.EnergyLoadTotal;
@@ -4380,7 +4383,7 @@ void CalcHeatEmissionReport(EnergyPlusData &state)
                 state.dataHeatBal->SysTotalHVACRejectHeatLoss +=
                     thisCoil.EvapCondPumpElecConsumption + thisCoil.BasinHeaterConsumption + thisCoil.EvapWaterConsump * RhoWater * H2OHtOfVap_HVAC;
             }
-        } else if (thisCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+        } else if (thisCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
             state.dataHeatBal->SysTotalHVACRejectHeatLoss +=
                 thisCoil.Energy + thisCoil.CrankcaseHeaterConsumption + thisCoil.DefrostConsumption - thisCoil.EnergyLoadTotal;
         }
@@ -4390,7 +4393,7 @@ void CalcHeatEmissionReport(EnergyPlusData &state)
     for (int iCoil = 1; iCoil <= state.dataHeatingCoils->NumHeatingCoils; ++iCoil) {
         auto const &thisCoil = state.dataHeatingCoils->HeatingCoil(iCoil);
 
-        if (thisCoil.HCoilType_Num == HVAC::Coil_HeatingGas_MultiStage || thisCoil.HCoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel) {
+        if (thisCoil.coilType == HVAC::CoilType::HeatingGasMultiStage || thisCoil.coilType == HVAC::CoilType::HeatingGasOrOtherFuel) {
             state.dataHeatBal->SysTotalHVACRejectHeatLoss += thisCoil.FuelUseLoad + thisCoil.ParasiticFuelConsumption - thisCoil.HeatingCoilLoad;
         }
     }
@@ -5251,7 +5254,7 @@ void WriteTabularReports(EnergyPlusData &state)
             WriteVisualResilienceTablesRepPeriod(state, i);
         }
 
-        state.dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(
+        ReportCoilSelection::finishCoilSummaryReportTable(
             state);                   // call to write out the coil selection summary table data
         WritePredefinedTables(state); // moved to come after zone load components is finished
 
@@ -15520,8 +15523,7 @@ void computeSpaceZoneCompLoads(EnergyPlusData &state,
                                    iSpace);
     CollectPeakZoneConditions(state, coolCompLoadTables, coolDesSelected, timeCoolMax, iZone, true, iSpace);
     // send latent load info to coil summary report
-    state.dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadCoolingIdealPeak(
-        iZone, coolCompLoadTables.cells(LoadCompCol::Latent, LoadCompRow::GrdTot));
+    ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(state, iZone, coolCompLoadTables.cells(LoadCompCol::Latent, LoadCompRow::GrdTot));
 
     int heatDesSelected = calcFinalSizing.HeatDDNum;
     heatCompLoadTables.desDayNum = heatDesSelected;
@@ -15559,8 +15561,7 @@ void computeSpaceZoneCompLoads(EnergyPlusData &state,
     CollectPeakZoneConditions(state, heatCompLoadTables, heatDesSelected, timeHeatMax, iZone, false, iSpace);
 
     // send latent load info to coil summary report
-    state.dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadHeatingIdealPeak(
-        iZone, heatCompLoadTables.cells(LoadCompCol::Latent, LoadCompRow::GrdTot));
+    ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(state, iZone, heatCompLoadTables.cells(LoadCompCol::Latent, LoadCompRow::GrdTot));
 
     AddAreaColumnForZone(componentAreas, coolCompLoadTables);
     AddAreaColumnForZone(componentAreas, heatCompLoadTables);
@@ -16016,7 +16017,7 @@ void CollectPeakZoneConditions(EnergyPlusData &state,
                 compLoad.peakDateHrMin = format("{}/{} {}",
                                                 state.dataWeather->DesDayInput(desDaySelected).Month,
                                                 state.dataWeather->DesDayInput(desDaySelected).DayOfMonth,
-                                                state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(state, timeOfMax));
+                                                ReportCoilSelection::getTimeText(state, timeOfMax));
             } else {
                 compLoad.peakDateHrMin = szCalcFinalSizing.CoolPeakDateHrMin;
             }
@@ -16068,7 +16069,7 @@ void CollectPeakZoneConditions(EnergyPlusData &state,
                 compLoad.peakDateHrMin = format("{}/{} {}",
                                                 state.dataWeather->DesDayInput(desDaySelected).Month,
                                                 state.dataWeather->DesDayInput(desDaySelected).DayOfMonth,
-                                                state.dataRptCoilSelection->coilSelectionReportObj->getTimeText(state, timeOfMax));
+                                                ReportCoilSelection::getTimeText(state, timeOfMax));
             } else {
                 compLoad.peakDateHrMin = szCalcFinalSizing.HeatPeakDateHrMin;
             }
diff --git a/src/EnergyPlus/PackagedThermalStorageCoil.cc b/src/EnergyPlus/PackagedThermalStorageCoil.cc
index a65d4682d43..b852c5c32c4 100644
--- a/src/EnergyPlus/PackagedThermalStorageCoil.cc
+++ b/src/EnergyPlus/PackagedThermalStorageCoil.cc
@@ -157,29 +157,43 @@ void SimTESCoil(EnergyPlusData &state,
         }
     }
 
+    SimTESCoil(state,
+               TESCoilNum, 
+               fanOp, 
+               TESOpMode,
+               PartLoadRatio);
+}
+
+void SimTESCoil(EnergyPlusData &state,
+                int const coilNum, 
+                HVAC::FanOp const fanOp, // allows parent object to control fan mode
+                PTSCOperatingMode &TESOpMode,
+                ObjexxFCL::Optional<Real64 const> PartLoadRatio // part load ratio (for single speed cycling unit)
+)
+{
     TESOpMode = PTSCOperatingMode::CoolingOnly;
 
-    InitTESCoil(state, TESCoilNum);
+    InitTESCoil(state, coilNum);
 
-    TESOpMode = state.dataPackagedThermalStorageCoil->TESCoil(TESCoilNum).CurControlMode;
+    TESOpMode = state.dataPackagedThermalStorageCoil->TESCoil(coilNum).CurControlMode;
     switch (TESOpMode) {
     case PTSCOperatingMode::Off:
-        CalcTESCoilOffMode(state, TESCoilNum);
+        CalcTESCoilOffMode(state, coilNum);
         break;
     case PTSCOperatingMode::CoolingOnly:
-        CalcTESCoilCoolingOnlyMode(state, TESCoilNum, fanOp, PartLoadRatio);
+        CalcTESCoilCoolingOnlyMode(state, coilNum, fanOp, PartLoadRatio);
         break;
     case PTSCOperatingMode::CoolingAndCharge:
-        CalcTESCoilCoolingAndChargeMode(state, TESCoilNum, fanOp, PartLoadRatio);
+        CalcTESCoilCoolingAndChargeMode(state, coilNum, fanOp, PartLoadRatio);
         break;
     case PTSCOperatingMode::CoolingAndDischarge:
-        CalcTESCoilCoolingAndDischargeMode(state, TESCoilNum, fanOp, PartLoadRatio);
+        CalcTESCoilCoolingAndDischargeMode(state, coilNum, fanOp, PartLoadRatio);
         break;
     case PTSCOperatingMode::ChargeOnly:
-        CalcTESCoilChargeOnlyMode(state, TESCoilNum);
+        CalcTESCoilChargeOnlyMode(state, coilNum);
         break;
     case PTSCOperatingMode::DischargeOnly:
-        CalcTESCoilDischargeOnlyMode(state, TESCoilNum, PartLoadRatio);
+        CalcTESCoilDischargeOnlyMode(state, coilNum, PartLoadRatio);
         break;
     default:
         assert(false);
@@ -1848,7 +1862,7 @@ void GetTESCoilInput(EnergyPlusData &state)
     }
 }
 
-void InitTESCoil(EnergyPlusData &state, int &TESCoilNum)
+void InitTESCoil(EnergyPlusData &state, int const TESCoilNum)
 {
 
     // SUBROUTINE INFORMATION:
@@ -2105,7 +2119,7 @@ void InitTESCoil(EnergyPlusData &state, int &TESCoilNum)
     thisTESCoil.ElectEvapCondBasinHeaterEnergy = 0.0;
 }
 
-void SizeTESCoil(EnergyPlusData &state, int &TESCoilNum)
+void SizeTESCoil(EnergyPlusData &state, int const TESCoilNum)
 {
 
     // SUBROUTINE INFORMATION:
@@ -4415,4 +4429,15 @@ void GetTESCoilCoolingAirFlowRate(
     }
 }
 
+int GetCoilIndex(EnergyPlusData &state, std::string const &coilName)
+{
+    if (state.dataPackagedThermalStorageCoil->GetTESInputFlag) {
+        GetTESCoilInput(state);
+        state.dataPackagedThermalStorageCoil->GetTESInputFlag = false;
+    }
+
+    return Util::FindItemInList(coilName, state.dataPackagedThermalStorageCoil->TESCoil);
+}
+
+
 } // namespace EnergyPlus::PackagedThermalStorageCoil
diff --git a/src/EnergyPlus/PackagedThermalStorageCoil.hh b/src/EnergyPlus/PackagedThermalStorageCoil.hh
index 369366e2ebe..8f4e95894f8 100644
--- a/src/EnergyPlus/PackagedThermalStorageCoil.hh
+++ b/src/EnergyPlus/PackagedThermalStorageCoil.hh
@@ -444,11 +444,18 @@ namespace PackagedThermalStorageCoil {
                     ObjexxFCL::Optional<Real64 const> PartLoadRatio = _ // part load ratio (for single speed cycling unit)
     );
 
+    void SimTESCoil(EnergyPlusData &state,
+                    int const coilNum,
+                    HVAC::FanOp const fanOp, // allows parent object to control fan mode
+                    PTSCOperatingMode &TESOpMode,
+                    ObjexxFCL::Optional<Real64 const> PartLoadRatio = _ // part load ratio (for single speed cycling unit)
+    );
+
     void GetTESCoilInput(EnergyPlusData &state);
 
-    void InitTESCoil(EnergyPlusData &state, int &TESCoilNum);
+    void InitTESCoil(EnergyPlusData &state, int const TESCoilNum);
 
-    void SizeTESCoil(EnergyPlusData &state, int &TESCoilNum);
+    void SizeTESCoil(EnergyPlusData &state, int const TESCoilNum);
 
     void CalcTESCoilOffMode(EnergyPlusData &state, int const TESCoilNum);
 
@@ -474,7 +481,7 @@ namespace PackagedThermalStorageCoil {
 
     void UpdateEvaporativeCondenserWaterUse(EnergyPlusData &state, int const TESCoilNum, Real64 const HumRatAfterEvap, int const InletNodeNum);
 
-    void GetTESCoilIndex(
+    void GetCoilIndex(
         EnergyPlusData &state, std::string const &CoilName, int &CoilIndex, bool &ErrorsFound, std::string_view const CurrentModuleObject = {});
 
     void GetTESCoilAirInletNode(
@@ -489,6 +496,16 @@ namespace PackagedThermalStorageCoil {
     void GetTESCoilCoolingAirFlowRate(
         EnergyPlusData &state, std::string const &CoilName, Real64 &CoilCoolAirFlow, bool &ErrorsFound, std::string const &CurrentModuleObject);
 
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilCoolingCapacity(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilCoolingAirFlowRate(EnergyPlusData &state, int const coilNum);
+  
 } // namespace PackagedThermalStorageCoil
 
 struct PackagedThermalStorageCoilData : BaseGlobalStruct
diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc
index 854628a6a62..c7a2cfba7c7 100644
--- a/src/EnergyPlus/PoweredInductionUnits.cc
+++ b/src/EnergyPlus/PoweredInductionUnits.cc
@@ -114,7 +114,6 @@ using HVAC::SmallMassFlow;
 using HVAC::SmallTempDiff;
 using Psychrometrics::PsyCpAirFnW;
 using Psychrometrics::PsyHFnTdbW;
-using SteamCoils::SimulateSteamCoilComponents;
 
 void SimPIU(EnergyPlusData &state,
             std::string_view CompName,     // name of the PIU
@@ -229,8 +228,6 @@ void GetPIUs(EnergyPlusData &state)
     using BranchNodeConnections::TestCompSet;
 
     using NodeInputManager::GetOnlySingleNode;
-    using SteamCoils::GetCoilSteamInletNode;
-    using WaterCoils::GetCoilWaterInletNode;
 
     static constexpr std::string_view routineName = "GetPIUs";
 
@@ -305,21 +302,43 @@ void GetPIUs(EnergyPlusData &state)
                 if (cCurrentModuleObject == "AirTerminal:SingleDuct:ParallelPIU:Reheat") {
                     thisPIU.FanOnFlowFrac = ip->getRealFieldValue(fields, objectSchemaProps, "fan_on_flow_fraction");
                 }
-                thisPIU.HCoilType = static_cast<HtgCoilType>(
-                    getEnumValue(HCoilNamesUC, Util::makeUPPER(ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_object_type"))));
-                switch (thisPIU.HCoilType) {
-                case HtgCoilType::SimpleHeating: {
-                    thisPIU.HCoil_PlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-                    break;
-                }
-                case HtgCoilType::Electric:
-                case HtgCoilType::Gas: {
-                    break;
-                }
-                case HtgCoilType::SteamAirHeating: {
-                    thisPIU.HCoil_PlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-                    thisPIU.HCoil_fluid = Fluid::GetSteam(state);
-                    if (thisPIU.HCoil_fluid == nullptr) {
+
+                std::string heatCoilTypeName = Util::makeUPPER(ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_object_type"));
+                thisPIU.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, heatCoilTypeName));
+
+                thisPIU.heatCoilName = ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_name");
+                
+                switch (thisPIU.heatCoilType) {
+                case HVAC::CoilType::HeatingWater: {
+                    thisPIU.heatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+                    thisPIU.heatCoilNum = WaterCoils::GetCoilIndex(state, thisPIU.heatCoilName);
+                    if (thisPIU.heatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, "reheat_coil_name", thisPIU.heatCoilName);
+                        ErrorsFound = true;
+                    }
+                                                    
+                } break;
+                  
+                case HVAC::CoilType::HeatingElectric:
+                case HVAC::CoilType::HeatingGasOrOtherFuel: {
+                    thisPIU.heatCoilNum = HeatingCoils::GetCoilIndex(state, thisPIU.heatCoilName);
+                    if (thisPIU.heatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, "reheat_coil_name", thisPIU.heatCoilName);
+                        ErrorsFound = true;
+                    }
+                } break;
+                  
+                case HVAC::CoilType::HeatingSteam: {
+                    thisPIU.heatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+                    
+                    thisPIU.heatCoilNum = SteamCoils::GetCoilIndex(state, thisPIU.heatCoilName);
+                    if (thisPIU.heatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, "reheat_coil_name", thisPIU.heatCoilName);
+                        ErrorsFound = true;
+                    }
+                    
+                    thisPIU.heatCoilFluid = Fluid::GetSteam(state);
+                    if (thisPIU.heatCoilFluid == nullptr) {
                         ShowSevereError(state, format("{} Steam Properties for {} not found.", RoutineName, thisPIU.Name));
                         if (SteamMessageNeeded) {
                             ShowContinueError(state, "Steam Fluid Properties should have been included in the input file.");
@@ -327,19 +346,19 @@ void GetPIUs(EnergyPlusData &state)
                         ErrorsFound = true;
                         SteamMessageNeeded = false;
                     }
-                    break;
-                }
+                } break;
+                  
                 default: {
-                    ShowSevereError(state, format("Illegal Reheat Coil Type = {}", thisPIU.HCoilType));
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisPIU.Name));
+                    ShowSevereInvalidKey(state, eoh, "reheat_coil_object_type", heatCoilTypeName);
                     ErrorsFound = true;
-                }
+                } break;
                 }
 
-                auto connectionType = DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctSeriesPIUReheat;
+                DataLoopNode::ConnectionObjectType connectionType = DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctSeriesPIUReheat;
                 if (cCurrentModuleObject == "AirTerminal:SingleDuct:ParallelPIU:Reheat") {
                     connectionType = DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctParallelPIUReheat;
                 }
+                
                 thisPIU.PriAirInNode = GetOnlySingleNode(state,
                                                          ip->getAlphaFieldValue(fields, objectSchemaProps, "supply_air_inlet_node_name"),
                                                          ErrorsFound,
@@ -385,18 +404,12 @@ void GetPIUs(EnergyPlusData &state)
                                                            "Reheat Coil Air Inlet Node Name");
                 // The reheat coil control node is necessary for hot water reheat, but not necessary for
                 // electric or gas reheat.
-                if (thisPIU.HCoilType == HtgCoilType::SimpleHeating) {
-                    thisPIU.HotControlNode = GetCoilWaterInletNode(state,
-                                                                   ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_object_type"),
-                                                                   ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_name"),
-                                                                   ErrorsFound);
-                }
-                if (thisPIU.HCoilType == HtgCoilType::SteamAirHeating) {
-                    thisPIU.HotControlNode = GetCoilSteamInletNode(state,
-                                                                   ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_object_type"),
-                                                                   ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_name"),
-                                                                   ErrorsFound);
+                if (thisPIU.heatCoilType == HVAC::CoilType::HeatingWater) {
+                    thisPIU.HotControlNode = WaterCoils::GetCoilWaterInletNode(state, thisPIU.heatCoilNum);
+                } else if (thisPIU.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                    thisPIU.HotControlNode = SteamCoils::GetCoilSteamInletNode(state, thisPIU.heatCoilNum);
                 }
+
                 thisPIU.MixerName = ip->getAlphaFieldValue(fields, objectSchemaProps, "zone_mixer_name");
                 thisPIU.FanName = ip->getAlphaFieldValue(fields, objectSchemaProps, "fan_name");
 
@@ -412,14 +425,6 @@ void GetPIUs(EnergyPlusData &state)
                     thisPIU.fanAvailSched = fan->availSched;
                 }
 
-                thisPIU.HCoil = ip->getAlphaFieldValue(fields, objectSchemaProps, "reheat_coil_name");
-                bool IsNotOK = false;
-                ValidateComponent(
-                    state, HCoilNamesUC[static_cast<int>(thisPIU.HCoilType)], thisPIU.HCoil, IsNotOK, cCurrentModuleObject + " - Heating Coil");
-                if (IsNotOK) {
-                    ShowContinueError(state, format("In {} = {}", cCurrentModuleObject, thisPIU.Name));
-                    ErrorsFound = true;
-                }
                 thisPIU.MaxVolHotWaterFlow = ip->getRealFieldValue(fields, objectSchemaProps, "maximum_hot_water_or_steam_flow_rate");
                 thisPIU.MinVolHotWaterFlow = ip->getRealFieldValue(fields, objectSchemaProps, "minimum_hot_water_or_steam_flow_rate");
                 thisPIU.HotControlOffset = ip->getRealFieldValue(fields, objectSchemaProps, "convergence_tolerance");
@@ -672,10 +677,10 @@ void InitPIU(EnergyPlusData &state,
     }
 
     if (state.dataPowerInductionUnits->MyPlantScanFlag(PIUNum) && allocated(state.dataPlnt->PlantLoop)) {
-        if ((thisPIU.HCoil_PlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
-            (thisPIU.HCoil_PlantType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
+        if ((thisPIU.heatCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
+            (thisPIU.heatCoilPlantType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
             bool errFlag = false;
-            ScanPlantLoopsForObject(state, thisPIU.HCoil, thisPIU.HCoil_PlantType, thisPIU.HWplantLoc, errFlag, _, _, _, _, _);
+            ScanPlantLoopsForObject(state, thisPIU.heatCoilName, thisPIU.heatCoilPlantType, thisPIU.HWplantLoc, errFlag, _, _, _, _, _);
             if (errFlag) {
                 ShowFatalError(state, "InitPIU: Program terminated due to previous condition(s).");
             }
@@ -765,7 +770,7 @@ void InitPIU(EnergyPlusData &state,
             }
         }
 
-        if (((thisPIU.HCoilType == HtgCoilType::SimpleHeating) || (thisPIU.HCoilType == HtgCoilType::SteamAirHeating)) &&
+        if (((thisPIU.heatCoilType == HVAC::CoilType::HeatingWater) || (thisPIU.heatCoilType == HVAC::CoilType::HeatingSteam)) &&
             !state.dataPowerInductionUnits->MyPlantScanFlag(PIUNum)) {
             InitComponentNodes(state, thisPIU.MinHotWaterFlow, thisPIU.MaxHotWaterFlow, thisPIU.HotControlNode, thisPIU.HotCoilOutNodeNum);
         }
@@ -843,11 +848,6 @@ void SizePIU(EnergyPlusData &state, int const PIUNum)
 
     // Using/Aliasing
     using namespace DataSizing;
-    using SteamCoils::GetCoilSteamInletNode;
-    using SteamCoils::GetCoilSteamOutletNode;
-    using WaterCoils::GetCoilWaterInletNode;
-    using WaterCoils::GetCoilWaterOutletNode;
-    using WaterCoils::SetCoilDesFlow;
 
     using PlantUtilities::MyPlantSizingIndex;
 
@@ -1176,17 +1176,17 @@ void SizePIU(EnergyPlusData &state, int const PIUNum)
             }
         } else {
             CheckZoneSizing(state, thisPIU.UnitType, thisPIU.Name);
-            if (Util::SameString(HCoilNamesUC[static_cast<int>(thisPIU.HCoilType)], "Coil:Heating:Water")) {
+            if (thisPIU.heatCoilType == HVAC::CoilType::HeatingWater) {
 
-                int const CoilWaterInletNode = GetCoilWaterInletNode(state, "Coil:Heating:Water", thisPIU.HCoil, ErrorsFound);
-                int const CoilWaterOutletNode = GetCoilWaterOutletNode(state, "Coil:Heating:Water", thisPIU.HCoil, ErrorsFound);
+                int const CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, thisPIU.heatCoilNum);
+                int const CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, thisPIU.heatCoilNum);
 
                 // Autosized maximum hot water flow for reporting
                 Real64 MaxVolHotWaterFlowDes = 0.0;
 
                 if (IsAutoSize) {
                     int const PltSizHeatNum =
-                        MyPlantSizingIndex(state, "Coil:Heating:Water", thisPIU.HCoil, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound);
+                        MyPlantSizingIndex(state, "Coil:Heating:Water", thisPIU.heatCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound);
                     if (PltSizHeatNum > 0) {
 
                         if (state.dataSize->TermUnitFinalZoneSizing(CurTermUnitSizingNum).DesHeatMassFlow >= SmallAirVolFlow) {
@@ -1268,15 +1268,15 @@ void SizePIU(EnergyPlusData &state, int const PIUNum)
                     state, thisPIU.UnitType, thisPIU.Name, "User-Specified Maximum Reheat Steam Flow Rate [m3/s]", thisPIU.MaxVolHotWaterFlow);
             }
         } else {
-            if (Util::SameString(HCoilNames[static_cast<int>(thisPIU.HCoilType)], "Coil:Heating:Steam")) {
+            if (thisPIU.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
-                int const CoilSteamInletNode = GetCoilSteamInletNode(state, "Coil:Heating:Steam", thisPIU.HCoil, ErrorsFound);
-                int const CoilSteamOutletNode = GetCoilSteamOutletNode(state, "Coil:Heating:Steam", thisPIU.HCoil, ErrorsFound);
+                int const CoilSteamInletNode = SteamCoils::GetCoilSteamInletNode(state, thisPIU.heatCoilNum);
+                int const CoilSteamOutletNode = SteamCoils::GetCoilSteamOutletNode(state, thisPIU.heatCoilNum);
                 Real64 MaxVolHotSteamFlowDes = 0.0; // Autosized maximum hot steam flow for reporting
 
                 if (IsAutoSize) {
                     int const PltSizHeatNum =
-                        MyPlantSizingIndex(state, "Coil:Heating:Steam", thisPIU.HCoil, CoilSteamInletNode, CoilSteamOutletNode, ErrorsFound);
+                        MyPlantSizingIndex(state, "Coil:Heating:Steam", thisPIU.heatCoilName, CoilSteamInletNode, CoilSteamOutletNode, ErrorsFound);
                     if (PltSizHeatNum > 0) {
                         if (state.dataSize->TermUnitFinalZoneSizing(CurTermUnitSizingNum).DesHeatMassFlow >= SmallAirVolFlow) {
                             Real64 const CoilInTemp =
@@ -1287,10 +1287,10 @@ void SizePIU(EnergyPlusData &state, int const PIUNum)
                             Real64 const DesMassFlow = state.dataEnvrn->StdRhoAir * TermUnitSizing(CurTermUnitSizingNum).AirVolFlow;
                             DesCoilLoad = PsyCpAirFnW(CoilOutHumRat) * DesMassFlow * (CoilOutTemp - CoilInTemp);
                             Real64 constexpr TempSteamIn = 100.00;
-                            Real64 const EnthSteamInDry = thisPIU.HCoil_fluid->getSatEnthalpy(state, TempSteamIn, 1.0, RoutineName);
-                            Real64 const EnthSteamOutWet = thisPIU.HCoil_fluid->getSatEnthalpy(state, TempSteamIn, 0.0, RoutineName);
+                            Real64 const EnthSteamInDry = thisPIU.heatCoilFluid->getSatEnthalpy(state, TempSteamIn, 1.0, RoutineName);
+                            Real64 const EnthSteamOutWet = thisPIU.heatCoilFluid->getSatEnthalpy(state, TempSteamIn, 0.0, RoutineName);
                             Real64 const LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet;
-                            Real64 const SteamDensity = thisPIU.HCoil_fluid->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
+                            Real64 const SteamDensity = thisPIU.heatCoilFluid->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
                             Real64 const Cp =
                                 Fluid::GetWater(state)->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp, RoutineName);
                             MaxVolHotSteamFlowDes =
@@ -1343,12 +1343,8 @@ void SizePIU(EnergyPlusData &state, int const PIUNum)
         TermUnitSizing(CurTermUnitSizingNum).MaxSTVolFlow = thisPIU.MaxVolHotSteamFlow;
         TermUnitSizing(CurTermUnitSizingNum).DesHeatingLoad = DesCoilLoad; // coil report
         TermUnitSizing(CurTermUnitSizingNum).InducesPlenumAir = thisPIU.InducesPlenumAir;
-        if (thisPIU.HCoilType == HtgCoilType::SimpleHeating) {
-            SetCoilDesFlow(state,
-                           HCoilNamesUC[static_cast<int>(thisPIU.HCoilType)],
-                           thisPIU.HCoil,
-                           TermUnitSizing(CurTermUnitSizingNum).AirVolFlow,
-                           ErrorsFound);
+        if (thisPIU.heatCoilType == HVAC::CoilType::HeatingWater) {
+            WaterCoils::SetCoilDesFlow(state, thisPIU.heatCoilNum, TermUnitSizing(CurTermUnitSizingNum).AirVolFlow);
         }
     }
 
@@ -1394,11 +1390,8 @@ void CalcSeriesPIU(EnergyPlusData &state,
 
     // Using/Aliasing
     using namespace DataZoneEnergyDemands;
-    using HeatingCoils::SimulateHeatingCoilComponents;
     using MixerComponent::SimAirMixer;
     using PlantUtilities::SetComponentFlowRate;
-    using SteamCoils::SimulateSteamCoilComponents;
-    using WaterCoils::SimulateWaterCoilComponents;
 
     // Locals
     // SUBROUTINE ARGUMENT DEFINITIONS:
@@ -1626,20 +1619,20 @@ void CalcSeriesPIU(EnergyPlusData &state,
     }
 
     // fire the heating coil
-    switch (thisPIU.HCoilType) {
-    case HtgCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+    switch (thisPIU.heatCoilType) {
+    case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
         if ((thisPIU.heatingOperatingMode == HeatOpModeType::HeaterOff) || (thisPIU.heatingOperatingMode == HeatOpModeType::StagedHeatFirstStage)) {
             // call the reheat coil with the NO FLOW condition
             Real64 mdot = 0.0;
             SetComponentFlowRate(state, mdot, thisPIU.HotControlNode, thisPIU.HotCoilOutNodeNum, thisPIU.HWplantLoc);
 
-            SimulateWaterCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, thisPIU.HCoil_Index);
+            WaterCoils::SimulateWaterCoilComponents(state, thisPIU.heatCoilNum, FirstHVACIteration);
         } else {
             // control water flow to obtain output matching QZnReq
             ControlCompOutput(state,
-                              thisPIU.HCoil,
+                              thisPIU.heatCoilName,
                               thisPIU.UnitType,
-                              thisPIU.HCoil_Index,
+                              thisPIU.heatCoilNum,
                               FirstHVACIteration,
                               QCoilReq,
                               thisPIU.HotControlNode,
@@ -1655,20 +1648,17 @@ void CalcSeriesPIU(EnergyPlusData &state,
                               _,
                               thisPIU.HWplantLoc);
         }
-        break;
-    }
-    case HtgCoilType::SteamAirHeating: { // COIL:STEAM:AIRHEATING
-        SimulateSteamCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, thisPIU.HCoil_Index, QCoilReq);
-        break;
-    }
-    case HtgCoilType::Electric: { // COIL:ELECTRIC:HEATING
-        SimulateHeatingCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, QCoilReq, thisPIU.HCoil_Index);
-        break;
-    }
-    case HtgCoilType::Gas: { // COIL:GAS:HEATING
-        SimulateHeatingCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, QCoilReq, thisPIU.HCoil_Index);
-        break;
-    }
+    } break;
+      
+    case HVAC::CoilType::HeatingSteam: { // COIL:STEAM:AIRHEATING
+        SteamCoils::SimulateSteamCoilComponents(state, thisPIU.heatCoilNum, FirstHVACIteration, QCoilReq);
+    } break;
+      
+    case HVAC::CoilType::HeatingElectric:  // COIL:ELECTRIC:HEATING
+    case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
+        HeatingCoils::SimulateHeatingCoilComponents(state, thisPIU.heatCoilNum, FirstHVACIteration, QCoilReq);
+    } break;
+      
     default:
         break;
     }
@@ -1735,11 +1725,8 @@ void CalcParallelPIU(EnergyPlusData &state,
     //     simulate coil at coil output that matches the zone load
 
     using namespace DataZoneEnergyDemands;
-    using HeatingCoils::SimulateHeatingCoilComponents;
     using MixerComponent::SimAirMixer;
     using PlantUtilities::SetComponentFlowRate;
-    using SteamCoils::SimulateSteamCoilComponents;
-    using WaterCoils::SimulateWaterCoilComponents;
 
     bool UnitOn(true); // TRUE if unit is on
     bool PriOn(true);  // TRUE if primary air available
@@ -1976,19 +1963,19 @@ void CalcParallelPIU(EnergyPlusData &state,
     }
 
     // fire the heating coil
-    switch (thisPIU.HCoilType) {
-    case HtgCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+    switch (thisPIU.heatCoilType) {
+    case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
         if ((thisPIU.heatingOperatingMode == HeatOpModeType::HeaterOff) || (thisPIU.heatingOperatingMode == HeatOpModeType::StagedHeatFirstStage)) {
             // call the reheat coil with the NO FLOW condition
             Real64 mdot = 0.0;
             SetComponentFlowRate(state, mdot, thisPIU.HotControlNode, thisPIU.HotCoilOutNodeNum, thisPIU.HWplantLoc);
-            SimulateWaterCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, thisPIU.HCoil_Index);
+            WaterCoils::SimulateWaterCoilComponents(state, thisPIU.heatCoilNum, FirstHVACIteration);
         } else {
             // control water flow to obtain output matching QZnReq
             ControlCompOutput(state,
-                              thisPIU.HCoil,
+                              thisPIU.heatCoilName,
                               thisPIU.UnitType,
-                              thisPIU.HCoil_Index,
+                              thisPIU.heatCoilNum,
                               FirstHVACIteration,
                               QCoilReq,
                               thisPIU.HotControlNode,
@@ -2004,20 +1991,17 @@ void CalcParallelPIU(EnergyPlusData &state,
                               _,
                               thisPIU.HWplantLoc);
         }
-        break;
-    }
-    case HtgCoilType::SteamAirHeating: { // COIL:STEAM:AIRHEATING
-        SimulateSteamCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, thisPIU.HCoil_Index, QCoilReq);
-        break;
-    }
-    case HtgCoilType::Electric: { // COIL:ELECTRIC:HEATING
-        SimulateHeatingCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, QCoilReq, thisPIU.HCoil_Index);
-        break;
-    }
-    case HtgCoilType::Gas: { // COIL:GAS:HEATING
-        SimulateHeatingCoilComponents(state, thisPIU.HCoil, FirstHVACIteration, QCoilReq, thisPIU.HCoil_Index);
-        break;
-    }
+    } break;
+      
+    case HVAC::CoilType::HeatingSteam: { // COIL:STEAM:AIRHEATING
+        SteamCoils::SimulateSteamCoilComponents(state, thisPIU.heatCoilNum, FirstHVACIteration, QCoilReq);
+    } break;
+      
+    case HVAC::CoilType::HeatingElectric: // COIL:ELECTRIC:HEATING
+    case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
+        HeatingCoils::SimulateHeatingCoilComponents(state, thisPIU.heatCoilNum, FirstHVACIteration, QCoilReq);
+    } break;
+      
     default:
         break;
     }
@@ -2570,7 +2554,7 @@ void PowIndUnitData::reportTerminalUnit(EnergyPlusData &state)
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinFlowSch, adu.Name, "n/a");
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMaxFlowReh, adu.Name, "n/a");
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, "n/a");
-    OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, HCoilNamesUC[(int)this->HCoilType]);
+    OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, HVAC::coilTypeNamesUC[(int)this->heatCoilType]);
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a");
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, HVAC::fanTypeNames[(int)this->fanType]);
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanName, adu.Name, this->FanName);
diff --git a/src/EnergyPlus/PoweredInductionUnits.hh b/src/EnergyPlus/PoweredInductionUnits.hh
index e55ca16e944..8ec6807e4d1 100644
--- a/src/EnergyPlus/PoweredInductionUnits.hh
+++ b/src/EnergyPlus/PoweredInductionUnits.hh
@@ -69,25 +69,6 @@ namespace PoweredInductionUnits {
 
     // Using/Aliasing
 
-    // Data
-    // MODULE PARAMETER DEFINITIONS
-    // coil types in this module
-    enum class HtgCoilType
-    {
-        Invalid = -1,
-        Gas,
-        Electric,
-        SimpleHeating,
-        SteamAirHeating,
-        Num
-    };
-
-    static constexpr std::array<std::string_view, static_cast<int>(HtgCoilType::Num)> HCoilNamesUC{
-        "COIL:HEATING:FUEL", "COIL:HEATING:ELECTRIC", "COIL:HEATING:WATER", "COIL:HEATING:STEAM"};
-
-    static constexpr std::array<std::string_view, static_cast<int>(HtgCoilType::Num)> HCoilNames{
-        "Coil:Heating:Fuel", "Coil:Heating:Electric", "Coil:Heating:Water", "Coil:Heating:Steam"};
-
     enum class FanCntrlType
     {
         Invalid = -1,
@@ -155,11 +136,13 @@ namespace PoweredInductionUnits {
         HVAC::FanType fanType;                    // index for fan type
         int Fan_Index;                            // store index for this fan
         Sched::Schedule *fanAvailSched = nullptr; // fan availability schedule
-        HtgCoilType HCoilType;                    // index for heating coil type
-        DataPlant::PlantEquipmentType HCoil_PlantType;
-        std::string HCoil; // name of heating coil component
-        int HCoil_Index;   // index to this heating coil
-        Fluid::RefrigProps *HCoil_fluid = nullptr;
+
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;
+        DataPlant::PlantEquipmentType heatCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+        std::string heatCoilName; // name of heating coil component
+        int heatCoilNum = 0;
+        Fluid::RefrigProps *heatCoilFluid = nullptr;
+      
         Real64 MaxVolHotWaterFlow; // m3/s
         Real64 MaxVolHotSteamFlow; // m3/s
         Real64 MaxHotWaterFlow;    // kg/s
@@ -210,8 +193,8 @@ namespace PoweredInductionUnits {
             : UnitType_Num(DataDefineEquip::ZnAirLoopEquipType::Invalid), MaxTotAirVolFlow(0.0), MaxTotAirMassFlow(0.0), MaxPriAirVolFlow(0.0),
               MaxPriAirMassFlow(0.0), MinPriAirFlowFrac(0.0), MinPriAirMassFlow(0.0), PriDamperPosition(0.0), MaxSecAirVolFlow(0.0),
               MaxSecAirMassFlow(0.0), FanOnFlowFrac(0.0), FanOnAirMassFlow(0.0), PriAirInNode(0), SecAirInNode(0), OutAirNode(0), HCoilInAirNode(0),
-              ControlCompTypeNum(0), CompErrIndex(0), Mixer_Num(0), fanType(HVAC::FanType::Invalid), Fan_Index(0), HCoilType(HtgCoilType::Invalid),
-              HCoil_PlantType(DataPlant::PlantEquipmentType::Invalid), HCoil_Index(0), MaxVolHotWaterFlow(0.0), MaxVolHotSteamFlow(0.0),
+              ControlCompTypeNum(0), CompErrIndex(0), Mixer_Num(0), fanType(HVAC::FanType::Invalid), Fan_Index(0), 
+              MaxVolHotWaterFlow(0.0), MaxVolHotSteamFlow(0.0),
               MaxHotWaterFlow(0.0), MaxHotSteamFlow(0.0), MinVolHotWaterFlow(0.0), MinHotSteamFlow(0.0), MinVolHotSteamFlow(0.0),
               MinHotWaterFlow(0.0), HotControlNode(0), HotCoilOutNodeNum(0), HotControlOffset(0.0), HWplantLoc{}, ADUNum(0), InducesPlenumAir(false),
               HeatingRate(0.0), HeatingEnergy(0.0), SensCoolRate(0.0), SensCoolEnergy(0.0), CtrlZoneNum(0), ctrlZoneInNodeIndex(0), AirLoopNum(0),
diff --git a/src/EnergyPlus/RefrigeratedCase.cc b/src/EnergyPlus/RefrigeratedCase.cc
index 763887bb134..62b6891e5cd 100644
--- a/src/EnergyPlus/RefrigeratedCase.cc
+++ b/src/EnergyPlus/RefrigeratedCase.cc
@@ -13542,6 +13542,20 @@ void GetRefrigeratedRackIndex(EnergyPlusData &state,
     }
 }
 
+int GetRefrigeratedRackIndex(EnergyPlusData &state,
+                             std::string const &rackName)
+{
+    CheckRefrigerationInput(state);
+    return Util::FindItemInList(rackName, state.dataRefrigCase->RefrigRack);
+}
+
+int GetRefrigeratedCondenserIndex(EnergyPlusData &state,
+                                  std::string const &condenserName)
+{
+    CheckRefrigerationInput(state);
+    return Util::FindItemInList(condenserName, state.dataRefrigCase->Condenser);
+}
+  
 void ReportRefrigerationComponents(EnergyPlusData &state)
 {
 
diff --git a/src/EnergyPlus/RefrigeratedCase.hh b/src/EnergyPlus/RefrigeratedCase.hh
index d4a5a5e046b..e2852233db7 100644
--- a/src/EnergyPlus/RefrigeratedCase.hh
+++ b/src/EnergyPlus/RefrigeratedCase.hh
@@ -1502,6 +1502,10 @@ namespace RefrigeratedCase {
                                   std::string_view const ThisObjectType = {},
                                   bool const SuppressWarning = false);
 
+    int GetRefrigeratedRackIndex(EnergyPlusData &state, std::string const &rackName); 
+
+    int GetRefrigeratedCondenserIndex(EnergyPlusData &state, std::string const &condenserName); 
+
     void ReportRefrigerationComponents(EnergyPlusData &state);
 
     void SumZoneImpacts(EnergyPlusData &state);
diff --git a/src/EnergyPlus/ReportCoilSelection.cc b/src/EnergyPlus/ReportCoilSelection.cc
index ceea33a21a1..65f52f20de0 100644
--- a/src/EnergyPlus/ReportCoilSelection.cc
+++ b/src/EnergyPlus/ReportCoilSelection.cc
@@ -73,10 +73,7 @@
 
 namespace EnergyPlus {
 
-void createCoilSelectionReportObj(EnergyPlusData &state)
-{
-    state.dataRptCoilSelection->coilSelectionReportObj = std::make_unique<ReportCoilSelection>();
-}
+namespace ReportCoilSelection {
 
 CoilSelectionData::CoilSelectionData( // constructor
     std::string const &coilName)
@@ -123,20 +120,20 @@ CoilSelectionData::CoilSelectionData( // constructor
     fanTypeName = "unknown";
 }
 
-void ReportCoilSelection::finishCoilSummaryReportTable(EnergyPlusData &state)
+void finishCoilSummaryReportTable(EnergyPlusData &state)
 {
     doFinalProcessingOfCoilData(state);
     writeCoilSelectionOutput(state);
     writeCoilSelectionOutput2(state);
 }
 
-void ReportCoilSelection::writeCoilSelectionOutput(EnergyPlusData &state)
+void writeCoilSelectionOutput(EnergyPlusData &state)
 {
 
     // make calls to fill out predefined tabular report entries for each coil selection report object
-    for (auto &c : coilSelectionDataObjs) {
+    for (auto *c : state.dataRptCoilSelection->coils) {
 
-        OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilType, c->coilName_, c->coilObjName);
+      OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilType, c->coilName_, HVAC::coilTypeNames[(int)c->coilType]);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilLocation, c->coilName_, c->coilLocation);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilHVACType, c->coilName_, c->typeHVACname);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilHVACName, c->coilName_, c->userNameforHVACsystem);
@@ -160,7 +157,7 @@ void ReportCoilSelection::writeCoilSelectionOutput(EnergyPlusData &state)
 
         // begin std 229 New coil connections table entries
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilName_CCs, c->coilName_, c->coilName_);
-        OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilType_CCs, c->coilName_, c->coilObjName);
+        OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilType_CCs, c->coilName_, HVAC::coilTypeNames[(int)c->coilType]);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilLoc_CCs, c->coilName_, c->coilLocation);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilHVACType_CCs, c->coilName_, c->typeHVACname);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoilHVACName_CCs, c->coilName_, c->userNameforHVACsystem);
@@ -429,12 +426,12 @@ void ReportCoilSelection::writeCoilSelectionOutput(EnergyPlusData &state)
     }
 }
 
-void ReportCoilSelection::writeCoilSelectionOutput2(EnergyPlusData &state)
+void writeCoilSelectionOutput2(EnergyPlusData &state)
 {
 
     // make calls to fill out predefined tabular report entries for each coil selection report object
-    for (auto &c : coilSelectionDataObjs) {
-        OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdch2CoilType, c->coilName_, c->coilObjName);
+    for (auto *c : state.dataRptCoilSelection->coils) {
+        OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdch2CoilType, c->coilName_, HVAC::coilTypeNames[(int)c->coilType]);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdch2CoilHVACType, c->coilName_, c->typeHVACname);
         OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdch2CoilHVACName, c->coilName_, c->userNameforHVACsystem);
 
@@ -523,17 +520,17 @@ void ReportCoilSelection::writeCoilSelectionOutput2(EnergyPlusData &state)
     }
 }
 
-void ReportCoilSelection::setCoilFinalSizes(EnergyPlusData &state,
+void setCoilFinalSizes(EnergyPlusData &state,
                                             std::string const &coilName,    // user-defined name of the coil
-                                            std::string const &coilObjName, //  coil object name, e.g., Coil:Cooling:Water
+                                            HVAC::CoilType const coilType, //  coil object name, e.g., Coil:Cooling:Water
                                             Real64 const totGrossCap,       // total capacity [W]
                                             Real64 const sensGrossCap,      // sensible capacity [W]
                                             Real64 const airFlowRate,       // design or reference or rated air flow rate [m3/s]
                                             Real64 const waterFlowRate      // design or reference or rated water flow rate [m3/s]
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilObjName);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     if (c != nullptr) {
         c->coilTotCapFinal = totGrossCap;
         c->coilSensCapFinal = sensGrossCap;
@@ -542,10 +539,27 @@ void ReportCoilSelection::setCoilFinalSizes(EnergyPlusData &state,
     }
 }
 
-void ReportCoilSelection::doAirLoopSetup(EnergyPlusData &state, int const coilVecIndex)
+void setCoilFinalSizes(EnergyPlusData &state,
+                                            int const coilReportNum,
+                                            Real64 const totGrossCap,       // total capacity [W]
+                                            Real64 const sensGrossCap,      // sensible capacity [W]
+                                            Real64 const airFlowRate,       // design or reference or rated air flow rate [m3/s]
+                                            Real64 const waterFlowRate      // design or reference or rated water flow rate [m3/s]
+)
+{
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
+    if (c != nullptr) {
+        c->coilTotCapFinal = totGrossCap;
+        c->coilSensCapFinal = sensGrossCap;
+        c->coilRefAirVolFlowFinal = airFlowRate;
+        c->coilRefWaterVolFlowFinal = waterFlowRate;
+    }
+}
+
+void doAirLoopSetup(EnergyPlusData &state, int const coilVecIndex)
 {
     // this routine sets up some things for central air systems, needs to follow setting of an airloop num
-    auto &c(coilSelectionDataObjs[coilVecIndex]);
+    auto *c = state.dataRptCoilSelection->coils[coilVecIndex];
     if (c->airloopNum > 0 && c->airloopNum <= int(state.dataAirSystemsData->PrimaryAirSystems.size())) {
         // see if there is an OA controller
         if (state.dataAirSystemsData->PrimaryAirSystems(c->airloopNum).OASysExists) {
@@ -591,9 +605,9 @@ void ReportCoilSelection::doAirLoopSetup(EnergyPlusData &state, int const coilVe
     }
 }
 
-void ReportCoilSelection::doZoneEqSetup(EnergyPlusData &state, int const coilVecIndex)
+void doZoneEqSetup(EnergyPlusData &state, int const coilVecIndex)
 {
-    auto &c(coilSelectionDataObjs[coilVecIndex]);
+    auto *c = state.dataRptCoilSelection->coils[coilVecIndex];
     c->coilLocation = "Zone";
     c->zoneNum.resize(1);
     c->zoneNum[0] = c->zoneEqNum;
@@ -620,8 +634,8 @@ void ReportCoilSelection::doZoneEqSetup(EnergyPlusData &state, int const coilVec
         }
         // fill out supply fan info
         auto *fan = state.dataFans->fans(state.dataAirSystemsData->PrimaryAirSystems(c->airloopNum).supFanNum);
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-            state, c->coilName_, c->coilObjName, fan->Name, fan->type, state.dataAirSystemsData->PrimaryAirSystems(c->airloopNum).supFanNum);
+        setCoilSupplyFanInfo(
+            state, c->coilName_, c->coilType, fan->Name, fan->type, state.dataAirSystemsData->PrimaryAirSystems(c->airloopNum).supFanNum);
     }
 
     if (c->zoneEqNum > 0) {
@@ -629,10 +643,10 @@ void ReportCoilSelection::doZoneEqSetup(EnergyPlusData &state, int const coilVec
     }
 }
 
-void ReportCoilSelection::doFinalProcessingOfCoilData(EnergyPlusData &state)
+void doFinalProcessingOfCoilData(EnergyPlusData &state)
 {
     // this routine does some final processing in preparation for writing out results
-    for (auto &c : coilSelectionDataObjs) {
+    for (auto *c : state.dataRptCoilSelection->coils) {
 
         // mine final/hard values from coil models
 
@@ -711,14 +725,14 @@ void ReportCoilSelection::doFinalProcessingOfCoilData(EnergyPlusData &state)
         // call psych routine to flush out moist air metrics from those available
         if (c->coilDesEntTemp != -999.0 && c->coilDesEntHumRat != -999.0) {
             c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::doFinalProcessingOfCoilData");
+                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "doFinalProcessingOfCoilData");
             if (c->coilDesEntHumRat != -999.0) {
                 c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
             }
         }
         if (c->oaPeakTemp != -999.0 && c->oaPeakHumRat != -999.0) {
             c->oaPeakWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->oaPeakTemp, c->oaPeakHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::doFinalProcessingOfCoilData");
+                state, c->oaPeakTemp, c->oaPeakHumRat, state.dataEnvrn->StdBaroPress, "doFinalProcessingOfCoilData");
         }
 
         if (c->waterLoopNum > 0 && c->pltSizNum > 0) {
@@ -726,15 +740,15 @@ void ReportCoilSelection::doFinalProcessingOfCoilData(EnergyPlusData &state)
             c->plantLoopName = state.dataPlnt->PlantLoop(c->waterLoopNum).Name;
             if (state.dataSize->PlantSizData(c->pltSizNum).LoopType != DataSizing::TypeOfPlantLoop::Steam) {
                 c->rhoFluid = state.dataPlnt->PlantLoop(c->waterLoopNum)
-                                  .glycol->getDensity(state, Constant::InitConvTemp, "ReportCoilSelection::doFinalProcessingOfCoilData");
+                                  .glycol->getDensity(state, Constant::InitConvTemp, "doFinalProcessingOfCoilData");
 
                 c->cpFluid = state.dataPlnt->PlantLoop(c->waterLoopNum)
-                                 .glycol->getSpecificHeat(state, Constant::InitConvTemp, "ReportCoilSelection::doFinalProcessingOfCoilData");
+                                 .glycol->getSpecificHeat(state, Constant::InitConvTemp, "doFinalProcessingOfCoilData");
             } else { // steam loop
                 c->rhoFluid = state.dataPlnt->PlantLoop(c->waterLoopNum)
-                                  .steam->getSatDensity(state, 100.0, 1.0, "ReportCoilSelection::doFinalProcessingOfCoilData");
+                                  .steam->getSatDensity(state, 100.0, 1.0, "doFinalProcessingOfCoilData");
                 c->cpFluid = state.dataPlnt->PlantLoop(c->waterLoopNum)
-                                 .steam->getSatSpecificHeat(state, 100.0, 0.0, "ReportCoilSelection::doFinalProcessingOfCoilData");
+                                 .steam->getSatSpecificHeat(state, 100.0, 0.0, "doFinalProcessingOfCoilData");
             }
             c->plantDesMaxMassFlowRate = state.dataPlnt->PlantLoop(c->waterLoopNum).MaxMassFlowRate;
             if (c->plantDesMaxMassFlowRate > 0.0 && c->coilDesWaterMassFlow > 0.0) {
@@ -829,59 +843,39 @@ void ReportCoilSelection::doFinalProcessingOfCoilData(EnergyPlusData &state)
     } // end for loop over each coil
 }
 
-int ReportCoilSelection::getIndexForOrCreateDataObjFromCoilName(EnergyPlusData &state,
-                                                                std::string const &coilName, // user-defined name of the coil
-                                                                std::string const &coilType  // idf input object class name of coil
-)
+int getReportIndex(EnergyPlusData &state,
+                   std::string const &coilName, // user-defined name of the coil
+                   HVAC::CoilType coilType  // idf input object class name of coil
+                   )
 {
-    int index(-1);
-    for (int i = 0; i < numCoilsReported_; i++) {
-        if (coilSelectionDataObjs[i] != nullptr) {
-            if (Util::SameString(coilSelectionDataObjs[i]->coilName_, coilName)) {
-                if (Util::SameString(coilSelectionDataObjs[i]->coilObjName, coilType)) {
-                    return index = i;
-                } else {
-                    // throw error  coil type does not match coil name, check for unique names across coil types
-                    ShowWarningError(state,
-                                     format("check for unique coil names across different coil types: {} occurs in both {} and {}",
-                                            coilName,
-                                            coilType,
-                                            coilSelectionDataObjs[i]->coilObjName));
+  for (int i = 0; i < state.dataRptCoilSelection->coils.size(); i++) {
+        auto *c = state.dataRptCoilSelection->coils[i];
+        if (c != nullptr) { // Why would this be nullptr?
+            if (Util::SameString(c->coilName_, coilName)) {
+                if (c->coilType == coilType) {
+                    return i;
                 }
+                // throw error  coil type does not match coil name, check for unique names across coil types
+                ShowWarningError(state,
+                                 format("check for unique coil names across different coil types: {} occurs in both {} and {}",
+                                        coilName,
+                                        HVAC::coilTypeNames[(int)coilType],
+                                        HVAC::coilTypeNames[(int)c->coilType]));
             }
         }
     }
 
-    if (index == -1) { // then did not find it
-        // check if really a coil type
-        bool found(false);
-        bool locIsCooling(false);
-        bool locIsHeating(false);
-        for (int loop = 1; loop <= HVAC::NumAllCoilTypes; ++loop) {
-            if (Util::SameString(coilType, HVAC::cAllCoilTypes(loop))) {
-                found = true;
-                locIsCooling = Util::SameString(coilType, HVAC::cCoolingCoilTypes(loop));
-                locIsHeating = Util::SameString(coilType, HVAC::cHeatingCoilTypes(loop));
-                break;
-            }
-        }
-        if (found) {
-            coilSelectionDataObjs.emplace_back(new CoilSelectionData(coilName));
-            index = coilSelectionDataObjs.size() - 1;
-            coilSelectionDataObjs[index]->coilObjName = coilType;
-            ++numCoilsReported_;
-            coilSelectionDataObjs[index]->isCooling = locIsCooling;
-            coilSelectionDataObjs[index]->isHeating = locIsHeating;
-        }
-    }
-
-    if (index == -1) {
-        ShowFatalError(state, format("getIndexForOrCreateDataObjFromCoilName: Developer error - not a coil: {} = {}", coilType, coilName));
-    }
-    return index;
+    auto *c = new CoilSelectionData(coilName);
+    
+    state.dataRptCoilSelection->coils.push_back(c);
+    c->coilType = coilType;
+    c->isCooling = HVAC::coilTypeIsCooling[(int)coilType];
+    c->isHeating = HVAC::coilTypeIsHeating[(int)coilType];
+  
+    return state.dataRptCoilSelection->coils.size() - 1;
 }
 
-void ReportCoilSelection::associateZoneCoilWithParent(EnergyPlusData &state, std::unique_ptr<CoilSelectionData> &c)
+void associateZoneCoilWithParent(EnergyPlusData &state, CoilSelectionData *c)
 {
     c->coilLocation = "Unknown";
     c->typeHVACname = "Unknown";
@@ -968,9 +962,9 @@ void ReportCoilSelection::associateZoneCoilWithParent(EnergyPlusData &state, std
     }
 }
 
-void ReportCoilSelection::setRatedCoilConditions(EnergyPlusData &state,
+void setRatedCoilConditions(EnergyPlusData &state,
                                                  std::string const &coilName,     // ! user-defined name of the coil
-                                                 std::string const &coilObjName,  //  coil object name, e.g., Coil:Cooling:Water
+                                                 HVAC::CoilType const coilType,  //  coil object name, e.g., Coil:Cooling:Water
                                                  Real64 const RatedCoilTotCap,    // ! rated coil total capacity [W]
                                                  Real64 const RatedCoilSensCap,   // rated coil sensible capacity [W]
                                                  Real64 const RatedAirMassFlow,   // rated coil design air mass flow rate [m3/s]
@@ -986,8 +980,8 @@ void ReportCoilSelection::setRatedCoilConditions(EnergyPlusData &state,
                                                  Real64 const RatedCoilEff        // rated coil effectiveness
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilObjName);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilRatedTotCap = RatedCoilTotCap;
     c->coilRatedSensCap = RatedCoilSensCap;
     c->ratedAirMassFlow = RatedAirMassFlow;
@@ -1016,24 +1010,24 @@ void ReportCoilSelection::setRatedCoilConditions(EnergyPlusData &state,
     c->ratedCoilOawbRef = RatedCoilOawbRef;
 }
 
-void ReportCoilSelection::setCoilAirFlow(EnergyPlusData &state,
+void setCoilAirFlow(EnergyPlusData &state,
                                          std::string const &coilName, // user-defined name of the coil
-                                         std::string const &coilType, // idf input object class name of coil
+                                         HVAC::CoilType const coilType, // idf input object class name of coil
                                          Real64 const airVdot,        // air flow rate in m3/s
                                          bool const isAutoSized       // true if air flow was autosized
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilDesVolFlow = airVdot;
     c->volFlowIsAutosized = isAutoSized;
 
     c->coilDesMassFlow = airVdot * state.dataEnvrn->StdRhoAir;
 }
 
-void ReportCoilSelection::setCoilWaterFlowNodeNums(EnergyPlusData &state,
+void setCoilWaterFlowNodeNums(EnergyPlusData &state,
                                                    std::string const &coilName, // user-defined name of the coil
-                                                   std::string const &coilType, // idf input object class name of coil
+                                                   HVAC::CoilType const coilType, // idf input object class name of coil
                                                    Real64 const waterVdot,      // plant fluid flow rate in m3/s
                                                    bool const isAutoSized,      // true if water flow was autosized
                                                    int const inletNodeNum,      // coil chw inlet node num
@@ -1046,21 +1040,20 @@ void ReportCoilSelection::setCoilWaterFlowNodeNums(EnergyPlusData &state,
         bool errorsfound = false;
         plantSizNum = PlantUtilities::MyPlantSizingIndex(state, "water coil", coilName, inletNodeNum, outletNodeNum, errorsfound);
     }
-    state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(
-        state, coilName, coilType, waterVdot, isAutoSized, plantSizNum, plantLoopNum);
+    setCoilWaterFlowPltSizNum(state, coilName, coilType, waterVdot, isAutoSized, plantSizNum, plantLoopNum);
 }
 
-void ReportCoilSelection::setCoilWaterFlowPltSizNum(EnergyPlusData &state,
+void setCoilWaterFlowPltSizNum(EnergyPlusData &state,
                                                     std::string const &coilName, // user-defined name of the coil
-                                                    std::string const &coilType, // idf input object class name of coil
+                                                    HVAC::CoilType const coilType, // idf input object class name of coil
                                                     Real64 const waterVdot,      // plant fluid flow rate in m3/s
                                                     bool const isAutoSized,      // true if water flow was autosized
                                                     int const plantSizNum,       // plant sizing structure index
                                                     int const plantLoopNum       // plant loop structure index
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->pltSizNum = plantSizNum;
     c->waterLoopNum = plantLoopNum;
     if (c->waterLoopNum > 0) {
@@ -1070,14 +1063,14 @@ void ReportCoilSelection::setCoilWaterFlowPltSizNum(EnergyPlusData &state,
     if (c->waterLoopNum > 0 && c->pltSizNum > 0) {
         if (state.dataSize->PlantSizData(c->pltSizNum).LoopType != DataSizing::TypeOfPlantLoop::Steam) {
             c->rhoFluid =
-                state.dataPlnt->PlantLoop(c->waterLoopNum).glycol->getDensity(state, Constant::InitConvTemp, "ReportCoilSelection::setCoilWaterFlow");
+                state.dataPlnt->PlantLoop(c->waterLoopNum).glycol->getDensity(state, Constant::InitConvTemp, "setCoilWaterFlow");
 
             c->cpFluid = state.dataPlnt->PlantLoop(c->waterLoopNum)
-                             .glycol->getSpecificHeat(state, Constant::InitConvTemp, "ReportCoilSelection::setCoilWaterFlow");
+                             .glycol->getSpecificHeat(state, Constant::InitConvTemp, "setCoilWaterFlow");
         } else { // steam loop
-            c->rhoFluid = state.dataPlnt->PlantLoop(c->waterLoopNum).steam->getSatDensity(state, 100.0, 1.0, "ReportCoilSelection::setCoilWaterFlow");
+            c->rhoFluid = state.dataPlnt->PlantLoop(c->waterLoopNum).steam->getSatDensity(state, 100.0, 1.0, "setCoilWaterFlow");
             c->cpFluid =
-                state.dataPlnt->PlantLoop(c->waterLoopNum).steam->getSatSpecificHeat(state, 100.0, 0.0, "ReportCoilSelection::setCoilWaterFlow");
+                state.dataPlnt->PlantLoop(c->waterLoopNum).steam->getSatSpecificHeat(state, 100.0, 0.0, "setCoilWaterFlow");
         }
     }
     if (c->rhoFluid > 0.0) {
@@ -1090,85 +1083,151 @@ void ReportCoilSelection::setCoilWaterFlowPltSizNum(EnergyPlusData &state,
     }
 }
 
-void ReportCoilSelection::setCoilEntAirTemp(EnergyPlusData &state,
+void setCoilEntAirTemp(EnergyPlusData &state,
                                             std::string const &coilName,    // user-defined name of the coil
-                                            std::string const &coilType,    // idf input object class name of coil
+                                            HVAC::CoilType const coilType,    // idf input object class name of coil
                                             Real64 const entAirDryBulbTemp, // degree C air entering coil
                                             int const curSysNum,            // airloop system number index, if non zero
                                             int const curZoneEqNum          // zone equipment list index, if non-zero
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    setCoilEntAirTemp(state, index, entAirDryBulbTemp, curSysNum, curZoneEqNum);
+}
+
+void setCoilEntAirTemp(EnergyPlusData &state,
+                                            int const coilReportNum,
+                                            Real64 const entAirDryBulbTemp, // degree C air entering coil
+                                            int const curSysNum,            // airloop system number index, if non zero
+                                            int const curZoneEqNum          // zone equipment list index, if non-zero
+)
+{
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
     c->coilDesEntTemp = entAirDryBulbTemp;
     c->airloopNum = curSysNum;
-    doAirLoopSetup(state, index);
+    doAirLoopSetup(state, coilReportNum);
     c->zoneEqNum = curZoneEqNum;
 }
 
-void ReportCoilSelection::setCoilEntAirHumRat(EnergyPlusData &state,
+void setCoilEntAirHumRat(EnergyPlusData &state,
                                               std::string const &coilName, // user-defined name of the coil
-                                              std::string const &coilType, // idf input object class name of coil
+                                              HVAC::CoilType const coilType, // idf input object class name of coil
                                               Real64 const entAirHumrat    //
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilDesEntHumRat = entAirHumrat;
 }
 
-void ReportCoilSelection::setCoilEntWaterTemp(EnergyPlusData &state,
+void setCoilEntAirHumRat(EnergyPlusData &state,
+                                              int const coilReportNum,
+                                              Real64 const entAirHumrat    //
+)
+{
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
+    c->coilDesEntHumRat = entAirHumrat;
+}
+
+
+void setCoilEntWaterTemp(EnergyPlusData &state,
                                               std::string const &coilName, // user-defined name of the coil
-                                              std::string const &coilType, // idf input object class name of coil
+                                              HVAC::CoilType const coilType, // idf input object class name of coil
+                                              Real64 const entWaterTemp    //
+)
+{
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
+    c->coilDesWaterEntTemp = entWaterTemp;
+}
+
+void setCoilEntWaterTemp(EnergyPlusData &state,
+                                              int const coilReportNum,
                                               Real64 const entWaterTemp    //
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
     c->coilDesWaterEntTemp = entWaterTemp;
 }
 
-void ReportCoilSelection::setCoilLvgWaterTemp(EnergyPlusData &state,
+
+void setCoilLvgWaterTemp(EnergyPlusData &state,
                                               std::string const &coilName, // user-defined name of the coil
-                                              std::string const &coilType, // idf input object class name of coil
+                                              HVAC::CoilType const coilType, // idf input object class name of coil
                                               Real64 const lvgWaterTemp    //
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilDesWaterLvgTemp = lvgWaterTemp;
 }
 
-void ReportCoilSelection::setCoilWaterDeltaT(EnergyPlusData &state,
+void setCoilLvgWaterTemp(EnergyPlusData &state,
+                                              int const coilReportNum,
+                                              Real64 const lvgWaterTemp    //
+)
+{
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
+    c->coilDesWaterLvgTemp = lvgWaterTemp;
+}
+
+void setCoilWaterDeltaT(EnergyPlusData &state,
                                              std::string const &coilName, // user-defined name of the coil
-                                             std::string const &coilType, // idf input object class name of coil
+                                             HVAC::CoilType const coilType, // idf input object class name of coil
                                              Real64 const CoilWaterDeltaT // degree C temperature difference used to size coil
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilDesWaterTempDiff = CoilWaterDeltaT;
 }
 
-void ReportCoilSelection::setCoilLvgAirTemp(EnergyPlusData &state,
+void setCoilWaterDeltaT(EnergyPlusData &state,
+                                             int const coilReportNum,
+                                             Real64 const CoilWaterDeltaT // degree C temperature difference used to size coil
+)
+{
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
+    c->coilDesWaterTempDiff = CoilWaterDeltaT;
+}
+
+void setCoilLvgAirTemp(EnergyPlusData &state,
                                             std::string const &coilName,   // user-defined name of the coil
-                                            std::string const &coilType,   // idf input object class name of coil
+                                            HVAC::CoilType const coilType,   // idf input object class name of coil
                                             Real64 const lvgAirDryBulbTemp //
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilDesLvgTemp = lvgAirDryBulbTemp;
 }
 
-void ReportCoilSelection::setCoilLvgAirHumRat(EnergyPlusData &state,
+void setCoilLvgAirTemp(EnergyPlusData &state,
+                                            int const coilReportNum,
+                                            Real64 const lvgAirDryBulbTemp //
+)
+{
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
+    c->coilDesLvgTemp = lvgAirDryBulbTemp;
+}
+
+void setCoilLvgAirHumRat(EnergyPlusData &state,
                                               std::string const &coilName, // user-defined name of the coil
-                                              std::string const &coilType, // idf input object class name of coil
+                                              HVAC::CoilType const coilType, // idf input object class name of coil
+                                              Real64 const lvgAirHumRat    //
+)
+{
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
+    c->coilDesLvgHumRat = lvgAirHumRat;
+}
+
+void setCoilLvgAirHumRat(EnergyPlusData &state,
+                                              int const coilReportNum,
                                               Real64 const lvgAirHumRat    //
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
     c->coilDesLvgHumRat = lvgAirHumRat;
 }
 
@@ -1177,13 +1236,41 @@ std::string PeakHrMinString(EnergyPlusData &state, const int designDay, const in
     return fmt::format("{}/{} {}",
                        state.dataWeather->DesDayInput(designDay).Month,
                        state.dataWeather->DesDayInput(designDay).DayOfMonth,
-                       ReportCoilSelection::getTimeText(state, timeStepAtPeak));
+                       getTimeText(state, timeStepAtPeak));
 }
 
-void ReportCoilSelection::setCoilCoolingCapacity(
+void setCoilCoolingCapacity(
     EnergyPlusData &state,
     std::string const &coilName,       // user-defined name of the coil
-    std::string const &coilType,       // idf input object class name of coil
+    HVAC::CoilType const coilType,       // idf input object class name of coil
+    Real64 const TotalCoolingCap,      // {W} coil cooling capacity, sizing result
+    bool const isAutoSize,             // true if value was autosized
+    int const curSysNum,               // airloop system number index, if non zero
+    int const curZoneEqNum,            // zone equipment list index, if non-zero
+    int const curOASysNum,             // OA system equipment list index, if non-zero
+    Real64 const fanCoolLoad,          // {W} fan load used in ideal loads coil sizing
+    Real64 const coilCapFunTempFac,    // {W} curve result for modification factor for capacity as a function of temperature
+    Real64 const DXFlowPerCapMinRatio, // non dimensional ratio, capacity adjustment ratio min
+    Real64 const DXFlowPerCapMaxRatio  // non dimensional ratio, capacity adjustment ratio max
+)
+{
+    int index = getReportIndex(state, coilName, coilType);
+    setCoilCoolingCapacity(state,
+                           index,
+                           TotalCoolingCap,
+                           isAutoSize,
+                           curSysNum,
+                           curZoneEqNum,
+                           curOASysNum,
+                           fanCoolLoad,
+                           coilCapFunTempFac,
+                           DXFlowPerCapMinRatio,
+                           DXFlowPerCapMaxRatio);
+}
+
+void setCoilCoolingCapacity(
+    EnergyPlusData &state,
+    int const coilReportNum,
     Real64 const TotalCoolingCap,      // {W} coil cooling capacity, sizing result
     bool const isAutoSize,             // true if value was autosized
     int const curSysNum,               // airloop system number index, if non zero
@@ -1198,8 +1285,7 @@ void ReportCoilSelection::setCoilCoolingCapacity(
     auto &ZoneEqSizing(state.dataSize->ZoneEqSizing);
     auto &SysSizPeakDDNum(state.dataSize->SysSizPeakDDNum);
 
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
     // no this is adjusted back to ratings    c->coilTotCapAtPeak = TotalCoolingCap;
     c->coilCapFTIdealPeak = coilCapFunTempFac;
     c->coilTotCapAtPeak = TotalCoolingCap * c->coilCapFTIdealPeak;
@@ -1209,7 +1295,7 @@ void ReportCoilSelection::setCoilCoolingCapacity(
 
     c->fanHeatGainIdealPeak = fanCoolLoad;
     c->airloopNum = curSysNum;
-    doAirLoopSetup(state, index);
+    doAirLoopSetup(state, coilReportNum);
     c->zoneEqNum = curZoneEqNum;
     //    if ( c->zoneEqNum > 0 ) doZoneEqSetup( index );
     c->oASysNum = curOASysNum;
@@ -1322,7 +1408,7 @@ void ReportCoilSelection::setCoilCoolingCapacity(
                 c->coilDesEntHumRat = finalSysSizing.OutHumRatAtCoolPeak;
             }
             c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilCoolingCapacity");
+                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "setCoilCoolingCapacity");
             c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
             if (c->coilDesLvgTemp == -999.0) { // don't overwrite if already set directly
                 c->coilDesLvgTemp = finalSysSizing.PrecoolTemp;
@@ -1331,7 +1417,7 @@ void ReportCoilSelection::setCoilCoolingCapacity(
                 c->coilDesLvgHumRat = finalSysSizing.PrecoolHumRat;
             }
             c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilCoolingCapacity");
+                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilCoolingCapacity");
             c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
 
         } else {                               // part of main air loop
@@ -1342,7 +1428,7 @@ void ReportCoilSelection::setCoilCoolingCapacity(
                 c->coilDesEntHumRat = finalSysSizing.MixHumRatAtCoolPeak;
             }
             c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilCoolingCapacity");
+                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "setCoilCoolingCapacity");
             c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
             if (c->coilDesLvgTemp == -999.0) {
                 c->coilDesLvgTemp = finalSysSizing.CoolSupTemp;
@@ -1351,7 +1437,7 @@ void ReportCoilSelection::setCoilCoolingCapacity(
                 c->coilDesLvgHumRat = finalSysSizing.CoolSupHumRat;
             }
             c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilCoolingCapacity");
+                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilCoolingCapacity");
             c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
             if (state.dataAirSystemsData->PrimaryAirSystems(curSysNum).NumOACoolCoils > 0) { // there is precooling of the OA stream
                 c->oaPretreated = true;
@@ -1433,7 +1519,7 @@ void ReportCoilSelection::setCoilCoolingCapacity(
             c->coilDesLvgHumRat = thisFinalZoneSizing.CoolDesHumRat;
         }
         c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-            state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilCoolingCapacity");
+            state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilCoolingCapacity");
         c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
     } else if (curOASysNum > 0 && c->airloopNum > state.dataHVACGlobal->NumPrimaryAirSys) {
         if (!state.dataAirLoopHVACDOAS->airloopDOAS.empty()) {
@@ -1442,14 +1528,14 @@ void ReportCoilSelection::setCoilCoolingCapacity(
             c->coilDesEntHumRat = state.dataAirLoopHVACDOAS->airloopDOAS[DOASSysNum].SizingCoolOAHumRat;
             if (c->coilDesEntTemp > -999.0 && c->coilDesEntHumRat > -999.0) {
                 c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                    state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilCoolingCapacity");
+                    state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "setCoilCoolingCapacity");
                 c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
             }
             c->coilDesLvgTemp = state.dataAirLoopHVACDOAS->airloopDOAS[DOASSysNum].PrecoolTemp;
             c->coilDesLvgHumRat = state.dataAirLoopHVACDOAS->airloopDOAS[DOASSysNum].PrecoolHumRat;
             if (c->coilDesLvgTemp > -999.0 && c->coilDesLvgHumRat > -999.0) {
                 c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                    state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilCoolingCapacity");
+                    state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilCoolingCapacity");
                 c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
             }
             DataSizing::SizingConcurrence sizMethod = DataSizing::SizingConcurrence::Invalid;
@@ -1478,10 +1564,39 @@ void ReportCoilSelection::setCoilCoolingCapacity(
     c->cpMoistAir = Psychrometrics::PsyCpAirFnW(c->coilDesEntHumRat);
 }
 
-void ReportCoilSelection::setCoilHeatingCapacity(
+void setCoilHeatingCapacity(
     EnergyPlusData &state,
     std::string const &coilName,       // user-defined name of the coil
-    std::string const &coilType,       // idf input object class name of coil
+    HVAC::CoilType const coilType,       // idf input object class name of coil
+    Real64 const totalHeatingCap,      // {W} coil Heating capacity
+    bool const isAutoSize,             // true if value was autosized
+    int const curSysNum,               // airloop system number index, if non zero
+    int const curZoneEqNum,            // zone equipment list index, if non-zero
+    int const curOASysNum,             // OA system equipment list index, if non-zero
+    Real64 const fanHeatGain,          // {W} fan load used in ideal loads coil sizing
+    Real64 const coilCapFunTempFac,    // {W} curve result for modification factor for capacity as a function of temperature
+    Real64 const DXFlowPerCapMinRatio, // non dimensional ratio, capacity adjustment ratio min
+    Real64 const DXFlowPerCapMaxRatio  // non dimensional ratio, capacity adjustment ratio max
+)
+{
+    int index = getReportIndex(state, coilName, coilType);
+    setCoilHeatingCapacity(
+        state,
+        index,
+        totalHeatingCap,
+        isAutoSize,
+        curSysNum,
+        curZoneEqNum,
+        curOASysNum,
+        fanHeatGain,
+        coilCapFunTempFac,
+        DXFlowPerCapMinRatio,
+        DXFlowPerCapMaxRatio);
+}
+
+void setCoilHeatingCapacity(
+    EnergyPlusData &state,
+    int coilReportNum,
     Real64 const totalHeatingCap,      // {W} coil Heating capacity
     bool const isAutoSize,             // true if value was autosized
     int const curSysNum,               // airloop system number index, if non zero
@@ -1493,8 +1608,7 @@ void ReportCoilSelection::setCoilHeatingCapacity(
     Real64 const DXFlowPerCapMaxRatio  // non dimensional ratio, capacity adjustment ratio max
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    auto *c = state.dataRptCoilSelection->coils[coilReportNum];
     c->capIsAutosized = isAutoSize;
     c->coilCapFTIdealPeak = coilCapFunTempFac;
     c->coilTotCapAtPeak = totalHeatingCap * c->coilCapFTIdealPeak;
@@ -1503,7 +1617,7 @@ void ReportCoilSelection::setCoilHeatingCapacity(
 
     c->fanHeatGainIdealPeak = fanHeatGain;
     c->airloopNum = curSysNum;
-    doAirLoopSetup(state, index);
+    doAirLoopSetup(state, coilReportNum);
     c->zoneEqNum = curZoneEqNum;
     //    if ( c->zoneEqNum > 0 ) doZoneEqSetup( index );
     if (curSysNum > 0 && c->zoneEqNum == 0 && curSysNum <= int(state.dataSize->FinalSysSizing.size())) {
@@ -1590,24 +1704,24 @@ void ReportCoilSelection::setCoilHeatingCapacity(
             if (c->coilDesEntTemp == -999.0) c->coilDesEntTemp = finalSysSizing.HeatOutTemp;
             if (c->coilDesEntHumRat == -999.0) c->coilDesEntHumRat = finalSysSizing.HeatOutHumRat;
             c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
             c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
             if (c->coilDesLvgTemp == -999.0) c->coilDesLvgTemp = finalSysSizing.PreheatTemp;
             if (c->coilDesLvgHumRat == -999.0) c->coilDesLvgHumRat = finalSysSizing.PreheatHumRat;
             c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
             c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
 
         } else { // part of main air loop
             if (c->coilDesEntTemp == -999.0) c->coilDesEntTemp = finalSysSizing.HeatMixTemp;
             if (c->coilDesEntHumRat == -999.0) c->coilDesEntHumRat = finalSysSizing.HeatMixHumRat;
             c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
             c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
             if (c->coilDesLvgTemp == -999.0) c->coilDesLvgTemp = finalSysSizing.HeatSupTemp;
             if (c->coilDesLvgHumRat == -999.0) c->coilDesLvgHumRat = finalSysSizing.HeatSupHumRat;
             c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+                state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
             c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
             if (state.dataAirSystemsData->PrimaryAirSystems(curSysNum).NumOAHeatCoils > 0) { // there is preHeating of the OA stream
                 c->oaPretreated = true;
@@ -1718,7 +1832,7 @@ void ReportCoilSelection::setCoilHeatingCapacity(
 
         if (c->coilDesEntTemp > -999.0 && c->coilDesEntHumRat > -999.0) {
             c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+                state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
             c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
         }
 
@@ -1729,7 +1843,7 @@ void ReportCoilSelection::setCoilHeatingCapacity(
             c->coilDesLvgHumRat = finalZoneSizing.HeatDesHumRat;
         }
         c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-            state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+            state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
         c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
     } else if (curOASysNum > 0 && c->airloopNum > int(state.dataSize->FinalSysSizing.size())) {
         if (!state.dataAirLoopHVACDOAS->airloopDOAS.empty()) {
@@ -1739,14 +1853,14 @@ void ReportCoilSelection::setCoilHeatingCapacity(
             c->coilDesEntHumRat = state.dataAirLoopHVACDOAS->airloopDOAS[DOASSysNum].HeatOutHumRat;
             if (c->coilDesEntTemp > -999.0 && c->coilDesEntHumRat > -999.0) {
                 c->coilDesEntWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                    state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+                    state, c->coilDesEntTemp, c->coilDesEntHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
                 c->coilDesEntEnth = Psychrometrics::PsyHFnTdbW(c->coilDesEntTemp, c->coilDesEntHumRat);
             }
             c->coilDesLvgTemp = state.dataAirLoopHVACDOAS->airloopDOAS[DOASSysNum].PreheatTemp;
             c->coilDesLvgHumRat = state.dataAirLoopHVACDOAS->airloopDOAS[DOASSysNum].PreheatHumRat;
             if (c->coilDesLvgTemp > -999.0 && c->coilDesLvgHumRat > -999.0) {
                 c->coilDesLvgWetBulb = Psychrometrics::PsyTwbFnTdbWPb(
-                    state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "ReportCoilSelection::setCoilHeatingCapacity");
+                    state, c->coilDesLvgTemp, c->coilDesLvgHumRat, state.dataEnvrn->StdBaroPress, "setCoilHeatingCapacity");
                 c->coilDesLvgEnth = Psychrometrics::PsyHFnTdbW(c->coilDesLvgTemp, c->coilDesLvgHumRat);
             }
             DataSizing::SizingConcurrence sizMethod = DataSizing::SizingConcurrence::Invalid;
@@ -1838,9 +1952,9 @@ void ReportCoilSelection::setCoilHeatingCapacity(
     c->coilSensCapAtPeak = min(c->coilSensCapAtPeak, c->coilTotCapAtPeak);
 }
 
-void ReportCoilSelection::setCoilWaterCoolingCapacity(EnergyPlusData &state,
+void setCoilWaterCoolingCapacity(EnergyPlusData &state,
                                                       std::string const &coilName,  // user-defined name of the coil
-                                                      std::string const &coilType,  // idf input object class name of coil
+                                                      HVAC::CoilType const coilType,  // idf input object class name of coil
                                                       Real64 const totalCoolingCap, // {W} coil cooling capacity
                                                       bool const isAutoSize,        // true if value was autosized
                                                       int const inletNodeNum,       // coil chw inlet node num
@@ -1848,8 +1962,8 @@ void ReportCoilSelection::setCoilWaterCoolingCapacity(EnergyPlusData &state,
                                                       int const dataWaterLoopNum    // plant loop structure index
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilTotCapAtPeak = totalCoolingCap;
     c->capIsAutosized = isAutoSize;
     if ((state.dataSize->NumPltSizInput > 0) && (inletNodeNum > 0) && (outletNodeNum > 0)) {
@@ -1861,9 +1975,9 @@ void ReportCoilSelection::setCoilWaterCoolingCapacity(EnergyPlusData &state,
     c->waterLoopNum = dataWaterLoopNum;
 }
 
-void ReportCoilSelection::setCoilWaterHeaterCapacityNodeNums(EnergyPlusData &state,
+void setCoilWaterHeaterCapacityNodeNums(EnergyPlusData &state,
                                                              std::string const &coilName,  // user-defined name of the coil
-                                                             std::string const &coilType,  // idf input object class name of coil
+                                                             HVAC::CoilType const coilType,  // idf input object class name of coil
                                                              Real64 const totalHeatingCap, // {W} coil Heating capacity
                                                              bool const isAutoSize,        // true if value was autosized
                                                              int const inletNodeNum,       // coil chw inlet node num
@@ -1871,8 +1985,8 @@ void ReportCoilSelection::setCoilWaterHeaterCapacityNodeNums(EnergyPlusData &sta
                                                              int const dataWaterLoopNum    // plant loop structure index
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilTotCapAtPeak = totalHeatingCap;
     c->capIsAutosized = isAutoSize;
     if ((state.dataSize->NumPltSizInput > 0) && (inletNodeNum > 0) && (outletNodeNum > 0)) {
@@ -1884,26 +1998,26 @@ void ReportCoilSelection::setCoilWaterHeaterCapacityNodeNums(EnergyPlusData &sta
     c->waterLoopNum = dataWaterLoopNum;
 }
 
-void ReportCoilSelection::setCoilWaterHeaterCapacityPltSizNum(EnergyPlusData &state,
+void setCoilWaterHeaterCapacityPltSizNum(EnergyPlusData &state,
                                                               std::string const &coilName,  // user-defined name of the coil
-                                                              std::string const &coilType,  // idf input object class name of coil
+                                                              HVAC::CoilType const coilType,  // idf input object class name of coil
                                                               Real64 const totalHeatingCap, // {W} coil Heating capacity
                                                               bool const isAutoSize,        // true if value was autosized
                                                               int const dataPltSizNum,      // plant sizing structure index
                                                               int const dataWaterLoopNum    // plant loop structure index
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilTotCapAtPeak = totalHeatingCap;
     c->capIsAutosized = isAutoSize;
     c->pltSizNum = dataPltSizNum;
     c->waterLoopNum = dataWaterLoopNum;
 }
 
-void ReportCoilSelection::setCoilUA(EnergyPlusData &state,
+void setCoilUA(EnergyPlusData &state,
                                     std::string const &coilName,            // user-defined name of the coil
-                                    std::string const &coilType,            // idf input object class name of coil
+                                    HVAC::CoilType const coilType,            // idf input object class name of coil
                                     Real64 const UAvalue,                   // [W/k] UA value for coil,
                                     Real64 const dataCapacityUsedForSizing, // [W] sizing global
                                     bool const isAutoSize,                  // true if value was autosized
@@ -1911,8 +2025,8 @@ void ReportCoilSelection::setCoilUA(EnergyPlusData &state,
                                     int const curZoneEqNum                  // zone equipment list index, if non-zero
 )
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->coilUA = UAvalue;
     c->coilTotCapAtPeak = dataCapacityUsedForSizing;
     c->capIsAutosized = isAutoSize;
@@ -1921,19 +2035,19 @@ void ReportCoilSelection::setCoilUA(EnergyPlusData &state,
     c->zoneEqNum = curZoneEqNum;
 }
 
-void ReportCoilSelection::setCoilReheatMultiplier(EnergyPlusData &state,
+void setCoilReheatMultiplier(EnergyPlusData &state,
                                                   std::string const &coilName, // user-defined name of the coil
-                                                  std::string const &coilType, // idf input object class name of coil
+                                                  HVAC::CoilType const coilType, // idf input object class name of coil
                                                   Real64 const multiplierReheatLoad)
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->reheatLoadMult = multiplierReheatLoad;
 }
 
-void ReportCoilSelection::setCoilSupplyFanInfo(EnergyPlusData &state,
+void setCoilSupplyFanInfo(EnergyPlusData &state,
                                                std::string const &coilName, // user-defined name of the coil
-                                               std::string const &coilType, // idf input object class name of coil
+                                               HVAC::CoilType const coilType, // idf input object class name of coil
                                                std::string const &fanName,
                                                HVAC::FanType fanType,
                                                int fanIndex)
@@ -1941,29 +2055,29 @@ void ReportCoilSelection::setCoilSupplyFanInfo(EnergyPlusData &state,
     if (fanName.empty()) {
         return;
     }
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->fanAssociatedWithCoilName = fanName;
     c->supFanType = fanType;
     c->supFanNum = fanIndex;
     if (c->supFanNum == 0) c->supFanNum = Fans::GetFanIndex(state, fanName);
 }
 
-void ReportCoilSelection::setCoilEqNum(EnergyPlusData &state,
+void setCoilEqNum(EnergyPlusData &state,
                                        std::string const &coilName,
-                                       std::string const &coilType,
+                                       HVAC::CoilType const coilType,
                                        int const curSysNum,
                                        int const curOASysNum,
                                        int const curZoneEqNum)
 {
-    int index = getIndexForOrCreateDataObjFromCoilName(state, coilName, coilType);
-    auto &c(coilSelectionDataObjs[index]);
+    int index = getReportIndex(state, coilName, coilType);
+    auto *c = state.dataRptCoilSelection->coils[index];
     c->airloopNum = curSysNum;
     c->oASysNum = curOASysNum;
     c->zoneEqNum = curZoneEqNum;
 }
 
-std::string ReportCoilSelection::getTimeText(EnergyPlusData &state, int const timeStepAtPeak)
+std::string getTimeText(EnergyPlusData &state, int const timeStepAtPeak)
 {
     std::string returnString = "";
 
@@ -1994,43 +2108,22 @@ std::string ReportCoilSelection::getTimeText(EnergyPlusData &state, int const ti
     return returnString;
 }
 
-bool ReportCoilSelection::isCompTypeFan(std::string const &compType // string component type, input object class name
+bool isCompTypeFan(std::string const &compType // string component type, input object class name
 )
 {
-    // if compType name is one of the fan objects, then return true
-    if (Util::SameString(compType, "Fan:SystemModel")) {
-        return true;
-    } else if (Util::SameString(compType, "Fan:ComponentModel")) {
-        return true;
-    } else if (Util::SameString(compType, "Fan:OnOff")) {
-        return true;
-    } else if (Util::SameString(compType, "Fan:ConstantVolume")) {
-        return true;
-    } else if (Util::SameString(compType, "Fan:VariableVolume")) {
-        return true;
-    } else {
-        return false;
-    }
+    return getEnumValue(HVAC::fanTypeNamesUC, Util::makeUPPER(compType)) != -1;
 }
 
-bool ReportCoilSelection::isCompTypeCoil(std::string const &compType // string component type, input object class name
+bool isCompTypeCoil(std::string const &compType // string component type, input object class name
 )
 {
-    // if compType name is one of the coil objects, then return true
-    bool found(false);
-    for (int loop = 1; loop <= HVAC::NumAllCoilTypes; ++loop) {
-        if (Util::SameString(compType, HVAC::cAllCoilTypes(loop))) {
-            found = true;
-            break;
-        }
-    }
-    return found;
+   return getEnumValue(HVAC::coilTypeNamesUC, Util::makeUPPER(compType)) != -1;
 }
 
-void ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(int const zoneIndex, Real64 const zoneCoolingLatentLoad)
+void setZoneLatentLoadCoolingIdealPeak(EnergyPlusData &state, int const zoneIndex, Real64 const zoneCoolingLatentLoad)
 {
     // loop over all the coils and the zones in the coils and if this zone index is in the coil
-    for (auto const &c : coilSelectionDataObjs) {
+    for (auto const &c : state.dataRptCoilSelection->coils) {
 
         if (c->isCooling) {
             for (std::size_t zoneInd = 0; zoneInd < c->zoneNum.size(); ++zoneInd) {
@@ -2043,10 +2136,10 @@ void ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(int const zoneIndex,
     }
 }
 
-void ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(int const zoneIndex, Real64 const zoneHeatingLatentLoad)
+void setZoneLatentLoadHeatingIdealPeak(EnergyPlusData &state, int const zoneIndex, Real64 const zoneHeatingLatentLoad)
 {
     // loop over all the coils and the zones in the coils and if this zone index is in the coil
-    for (auto const &c : coilSelectionDataObjs) {
+    for (auto *c : state.dataRptCoilSelection->coils) {
 
         if (c->isHeating) {
             for (std::size_t zoneInd = 0; zoneInd < c->zoneNum.size(); ++zoneInd) {
@@ -2059,4 +2152,5 @@ void ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(int const zoneIndex,
     }
 }
 
+} // namespace ReportCoilSelection
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/ReportCoilSelection.hh b/src/EnergyPlus/ReportCoilSelection.hh
index 8be2540c3c6..657a70895ee 100644
--- a/src/EnergyPlus/ReportCoilSelection.hh
+++ b/src/EnergyPlus/ReportCoilSelection.hh
@@ -64,6 +64,9 @@ namespace EnergyPlus {
 // Forward declarations
 struct EnergyPlusData;
 
+namespace ReportCoilSelection
+{
+  
 class CoilSelectionData
 // data object, one for each unique coil in simulation
 {
@@ -74,7 +77,7 @@ public: // methods
 
 public:                                  // data
     std::string coilName_;               // user-defined coil name
-    std::string coilObjName;             // coil object name, e.g., Coil:Cooling:Water, Coil:Heating:DX:SingleSpeed, etc.
+    HVAC::CoilType coilType = HVAC::CoilType::Invalid;
     bool isCooling;                      // true if this coil is for cooling
     bool isHeating;                      // true if this coil is for heating
     std::string coilLocation;            // where is the coil located?, AirLoop or Zone
@@ -219,20 +222,11 @@ public:                                  // data
 
 }; // end class CoilSelectionData
 
-class ReportCoilSelection
-
-{
-public: // Creation
-    ReportCoilSelection() : numCoilsReported_(0)
-    {
-    }
-
-public: // methods
     void finishCoilSummaryReportTable(EnergyPlusData &state);
 
     void setCoilFinalSizes(EnergyPlusData &state,
                            std::string const &coilName,    // user-defined name of the coil
-                           std::string const &coilObjName, //  coil object name, e.g., Coil:Cooling:Water
+                           HVAC::CoilType const coilType, //  coil type, e.g., Coil:Cooling:Water
                            Real64 const totGrossCap,       // total capacity [W]
                            Real64 const sensGrossCap,      // sensible capacity [W]
                            Real64 const airFlowRate,       // design or reference or rated air flow rate [m3/s]
@@ -241,7 +235,7 @@ public: // methods
 
     void setRatedCoilConditions(EnergyPlusData &state,
                                 std::string const &coilName,     // ! user-defined name of the coil
-                                std::string const &coilObjName,  //  coil object name, e.g., Coil:Cooling:Water
+                                HVAC::CoilType const coilType,  //  coil object name, e.g., Coil:Cooling:Water
                                 Real64 const RatedCoilTotCap,    // ! rated coil total capacity [W]
                                 Real64 const RatedCoilSensCap,   // rated coil sensible capacity [W]
                                 Real64 const RatedAirMassFlow,   // rated coil design air mass flow rate [m3/s]
@@ -260,14 +254,14 @@ public: // methods
 
     void setCoilAirFlow(EnergyPlusData &state,
                         std::string const &coilName, // user-defined name of the coil
-                        std::string const &coilType, // idf input object class name of coil
+                        HVAC::CoilType coilType, // idf input object class name of coil
                         Real64 const airVdot,        // air flow rate in m3/s
                         bool const isAutoSized       // true if air flow was autosized
     );
 
     void setCoilWaterFlowNodeNums(EnergyPlusData &state,
                                   std::string const &coilName, // user-defined name of the coil
-                                  std::string const &coilType, // idf input object class name of coil
+                                  HVAC::CoilType coilType, // idf input object class name of coil
                                   Real64 const waterVdot,      // water flow rate in m3/s
                                   bool const isAutoSized,      // true if water flow was autosized
                                   int const inletNodeNum,      // coil chw inlet node num
@@ -277,7 +271,7 @@ public: // methods
 
     void setCoilWaterFlowPltSizNum(EnergyPlusData &state,
                                    std::string const &coilName, // user-defined name of the coil
-                                   std::string const &coilType, // idf input object class name of coil
+                                   HVAC::CoilType coilType, // idf input object class name of coil
                                    Real64 const waterVdot,      // water flow rate in m3/s
                                    bool const isAutoSized,      // true if water flow was autosized
                                    int const DataPltSizNum,     // plant sizing structure index
@@ -286,7 +280,7 @@ public: // methods
 
     void setCoilEntAirTemp(EnergyPlusData &state,
                            std::string const &coilName,    // user-defined name of the coil
-                           std::string const &coilType,    // idf input object class name of coil
+                           HVAC::CoilType coilType,    // idf input object class name of coil
                            Real64 const entAirDryBulbTemp, // ideal loads sizing result for air entering coil drybulb temp (C)
                            int const curSysNum,            // airloop system number index, if non zero
                            int const curZoneEqNum          // zone equipment list index, if non-zero
@@ -294,42 +288,42 @@ public: // methods
 
     void setCoilEntAirHumRat(EnergyPlusData &state,
                              std::string const &coilName, // user-defined name of the coil
-                             std::string const &coilType, // idf input object class name of coil
+                             HVAC::CoilType coilType, // idf input object class name of coil
                              Real64 const entAirHumRat);
 
     void setCoilEntWaterTemp(EnergyPlusData &state,
                              std::string const &coilName, // user-defined name of the coil
-                             std::string const &coilType, // idf input object class name of coil
+                             HVAC::CoilType coilType, // idf input object class name of coil
                              Real64 const entWaterTemp    // degree C
     );
 
     void setCoilLvgWaterTemp(EnergyPlusData &state,
                              std::string const &coilName, // user-defined name of the coil
-                             std::string const &coilType, // idf input object class name of coil
+                             HVAC::CoilType coilType, // idf input object class name of coil
                              Real64 const lvgWaterTemp    // degree C
     );
 
     void setCoilWaterDeltaT(EnergyPlusData &state,
                             std::string const &coilName, // user-defined name of the coil
-                            std::string const &coilType, // idf input object class name of coil
+                            HVAC::CoilType coilType, // idf input object class name of coil
                             Real64 const CoilWaterDeltaT // degree C temperature difference used to size coil
     );
 
     void setCoilLvgAirTemp(EnergyPlusData &state,
                            std::string const &coilName,   // user-defined name of the coil
-                           std::string const &coilType,   // idf input object class name of coil
+                           HVAC::CoilType coilType,   // idf input object class name of coil
                            Real64 const lvgAirDryBulbTemp // air temperature leaving coil {C}
     );
 
     void setCoilLvgAirHumRat(EnergyPlusData &state,
                              std::string const &coilName, // user-defined name of the coil
-                             std::string const &coilType, // idf input object class name of coil
+                             HVAC::CoilType coilType, // idf input object class name of coil
                              Real64 const lvgAirHumRat    //
     );
 
     void setCoilCoolingCapacity(EnergyPlusData &state,
                                 std::string const &coilName,    // user-defined name of the coil
-                                std::string const &coilType,    // idf input object class name of coil
+                                HVAC::CoilType coilType,    // idf input object class name of coil
                                 Real64 const totalCoolingCap,   // {W} coil cooling capacity
                                 bool const isAutoSize,          // true if value was autosized
                                 int const curSysNum,            // airloop system number index, if non zero
@@ -343,7 +337,7 @@ public: // methods
 
     void setCoilHeatingCapacity(EnergyPlusData &state,
                                 std::string const &coilName,    // user-defined name of the coil
-                                std::string const &coilType,    // idf input object class name of coil
+                                HVAC::CoilType coilType,    // idf input object class name of coil
                                 Real64 const totalHeatingCap,   // {W} coil Heating capacity
                                 bool const isAutoSize,          // true if value was autosized
                                 int const curSysNum,            // airloop system number index, if non zero
@@ -357,7 +351,7 @@ public: // methods
 
     void setCoilWaterCoolingCapacity(EnergyPlusData &state,
                                      std::string const &coilName,  // user-defined name of the coil
-                                     std::string const &coilType,  // idf input object class name of coil
+                                     HVAC::CoilType coilType,  // idf input object class name of coil
                                      Real64 const totalCoolingCap, // {W} coil cooling capacity
                                      bool const isAutoSize,        // true if value was autosized
                                      int const inletNodeNum,       // coil chw inlet node num
@@ -367,7 +361,7 @@ public: // methods
 
     void setCoilWaterHeaterCapacityNodeNums(EnergyPlusData &state,
                                             std::string const &coilName,  // user-defined name of the coil
-                                            std::string const &coilType,  // idf input object class name of coil
+                                            HVAC::CoilType coilType,  // idf input object class name of coil
                                             Real64 const totalHeatingCap, // {W} coil Heating capacity
                                             bool const isAutoSize,        // true if value was autosized
                                             int const inletNodeNum,       // coil chw inlet node num
@@ -377,7 +371,7 @@ public: // methods
 
     void setCoilWaterHeaterCapacityPltSizNum(EnergyPlusData &state,
                                              std::string const &coilName,  // user-defined name of the coil
-                                             std::string const &coilType,  // idf input object class name of coil
+                                             HVAC::CoilType coilType,  // idf input object class name of coil
                                              Real64 const totalHeatingCap, // {W} coil Heating capacity
                                              bool const isAutoSize,        // true if value was autosized
                                              int const dataPltSizNum,      // plant sizing structure index
@@ -386,7 +380,7 @@ public: // methods
 
     void setCoilUA(EnergyPlusData &state,
                    std::string const &coilName,            // user-defined name of the coil
-                   std::string const &coilType,            // idf input object class name of coil
+                   HVAC::CoilType coilType,            // idf input object class name of coil
                    Real64 const UAvalue,                   // [W/k] UA value for coil,
                    Real64 const dataCapacityUsedForSizing, // [W] sizing global
                    bool const isAutoSize,                  // true if value was autosized
@@ -396,24 +390,185 @@ public: // methods
 
     void setCoilReheatMultiplier(EnergyPlusData &state,
                                  std::string const &coilName, // user-defined name of the coil
-                                 std::string const &coilType, // idf input object class name of coil
+                                 HVAC::CoilType coilType, // idf input object class name of coil
                                  Real64 const multiplierReheatLoad);
 
     void setCoilSupplyFanInfo(EnergyPlusData &state,
                               std::string const &coilName, // user-defined name of the coil
-                              std::string const &coilType, // idf input object class name of coil
+                              HVAC::CoilType coilType, // idf input object class name of coil
                               std::string const &fanName,
                               HVAC::FanType fanType,
                               int fanIndex);
 
     void setCoilEqNum(EnergyPlusData &state,
                       std::string const &coilName,
-                      std::string const &coilType,
+                      HVAC::CoilType coilType,
                       int const curSysNum,
                       int const curOASysNum,
                       int const curZoneEqNum);
 
-    static std::string getTimeText(EnergyPlusData &state, int const timeStepAtPeak);
+    void setCoilFinalSizes(EnergyPlusData &state,
+                           int const coilReportNum,
+                           Real64 const totGrossCap,       // total capacity [W]
+                           Real64 const sensGrossCap,      // sensible capacity [W]
+                           Real64 const airFlowRate,       // design or reference or rated air flow rate [m3/s]
+                           Real64 const waterFlowRate      // design or reference or rated water flow rate [m3/s]
+    );
+
+    void setRatedCoilConditions(EnergyPlusData &state,
+                                int const coilReportNum,
+                                Real64 const RatedCoilTotCap,    // ! rated coil total capacity [W]
+                                Real64 const RatedCoilSensCap,   // rated coil sensible capacity [W]
+                                Real64 const RatedAirMassFlow,   // rated coil design air mass flow rate [m3/s]
+                                Real64 const RatedCoilInDb,      // rated coil inlet air dry bulb at time of peak [C]
+                                Real64 const RatedCoilInHumRat,  // rated coil inlet air humidity ratio [kgWater/kgDryAir]
+                                Real64 const RatedCoilInWb,      // rated coil inlet air wet bulb [C]
+                                Real64 const RatedCoilOutDb,     // rated coil outlet air dry bulb [C]
+                                Real64 const RatedCoilOutHumRat, // rated coil outlet air humidity ratio, [kgWater/kgDryAir]
+                                Real64 const RatedCoilOutWb,     // rated coil outlet air wet bulb [C]
+
+                                Real64 const RatedCoilOadbRef,  // rated DX coil outside air dry bulb reference [C]
+                                Real64 const RatedCoilOawbRef,  // rated DX coil outside air wet bulb reference [C]
+                                Real64 const RatedCoilBpFactor, // rated coil bypass factor
+                                Real64 const RatedCoilEff       // rated coil effectiveness
+    );
+
+    void setCoilAirFlow(EnergyPlusData &state,
+                        int const coilReportNum,
+                        Real64 const airVdot,        // air flow rate in m3/s
+                        bool const isAutoSized       // true if air flow was autosized
+    );
+
+    void setCoilWaterFlowNodeNums(EnergyPlusData &state,
+                                  int const coilReportNum,
+                                  Real64 const waterVdot,      // water flow rate in m3/s
+                                  bool const isAutoSized,      // true if water flow was autosized
+                                  int const inletNodeNum,      // coil chw inlet node num
+                                  int const outletNodeNum,     // coil chw outlet node num
+                                  int const DataWaterLoopNum   // plant loop structure index
+    );
+
+    void setCoilWaterFlowPltSizNum(EnergyPlusData &state,
+                                   int const coilReportNum,
+                                   Real64 const waterVdot,      // water flow rate in m3/s
+                                   bool const isAutoSized,      // true if water flow was autosized
+                                   int const DataPltSizNum,     // plant sizing structure index
+                                   int const DataWaterLoopNum   // plant loop structure index
+    );
+
+    void setCoilEntAirTemp(EnergyPlusData &state,
+                           int const coilReportNum,
+                           Real64 const entAirDryBulbTemp, // ideal loads sizing result for air entering coil drybulb temp (C)
+                           int const curSysNum,            // airloop system number index, if non zero
+                           int const curZoneEqNum          // zone equipment list index, if non-zero
+    );
+
+    void setCoilEntAirHumRat(EnergyPlusData &state,
+                             int const coilReportNum,
+                             Real64 const entAirHumRat);
+
+    void setCoilEntWaterTemp(EnergyPlusData &state,
+                             int const coilReportNum,
+                             Real64 const entWaterTemp    // degree C
+    );
+
+    void setCoilLvgWaterTemp(EnergyPlusData &state,
+                             int const coilReportNum,
+                             Real64 const lvgWaterTemp    // degree C
+    );
+
+    void setCoilWaterDeltaT(EnergyPlusData &state,
+                            int const coilReportNum,
+                            Real64 const CoilWaterDeltaT // degree C temperature difference used to size coil
+    );
+
+    void setCoilLvgAirTemp(EnergyPlusData &state,
+                           int const coilReportNum,
+                           Real64 const lvgAirDryBulbTemp // air temperature leaving coil {C}
+    );
+
+    void setCoilLvgAirHumRat(EnergyPlusData &state,
+                             int const coilReportNum,
+                             Real64 const lvgAirHumRat    //
+    );
+
+    void setCoilCoolingCapacity(EnergyPlusData &state,
+                                int const coilReportNum,
+                                Real64 const totalCoolingCap,   // {W} coil cooling capacity
+                                bool const isAutoSize,          // true if value was autosized
+                                int const curSysNum,            // airloop system number index, if non zero
+                                int const curZoneEqNum,         // zone equipment list index, if non-zero
+                                int const curOASysNum,          // OA system equipment list index, if non-zero
+                                Real64 const fanCoolLoad,       // {W} fan load used in ideal loads coil sizing
+                                Real64 const coilCapFunTempFac, // {W} curve result for modification factor for capacity as a function of temperature
+                                Real64 const DXFlowPerCapMinRatio, // non dimensional ratio, capacity adjustment ratio min
+                                Real64 const DXFlowPerCapMaxRatio  // non dimensional ratio, capacity adjustment ratio max
+    );
+
+    void setCoilHeatingCapacity(EnergyPlusData &state,
+                                int const coilReportNum,
+                                Real64 const totalHeatingCap,   // {W} coil Heating capacity
+                                bool const isAutoSize,          // true if value was autosized
+                                int const curSysNum,            // airloop system number index, if non zero
+                                int const curZoneEqNum,         // zone equipment list index, if non-zero
+                                int const curOASysNum,          // OA system equipment list index, if non-zero
+                                Real64 const fanHeatGain,       // {W} fan load used in ideal loads coil sizing
+                                Real64 const coilCapFunTempFac, // {W} curve result for modification factor for capacity as a function of temperature
+                                Real64 const DXFlowPerCapMinRatio, // non dimensional ratio, capacity adjustment ratio min
+                                Real64 const DXFlowPerCapMaxRatio  // non dimensional ratio, capacity adjustment ratio max
+    );
+
+    void setCoilWaterCoolingCapacity(EnergyPlusData &state,
+                                     int const coilReportNum,
+                                     Real64 const totalCoolingCap, // {W} coil cooling capacity
+                                     bool const isAutoSize,        // true if value was autosized
+                                     int const inletNodeNum,       // coil chw inlet node num
+                                     int const outletNodeNum,      // coil chw outlet node num
+                                     int const dataWaterLoopNum    // plant loop structure index
+    );
+
+    void setCoilWaterHeaterCapacityNodeNums(EnergyPlusData &state,
+                                            int const coilReportNum,
+                                            Real64 const totalHeatingCap, // {W} coil Heating capacity
+                                            bool const isAutoSize,        // true if value was autosized
+                                            int const inletNodeNum,       // coil chw inlet node num
+                                            int const outletNodeNum,      // coil chw outlet node num
+                                            int const dataWaterLoopNum    // plant loop structure index
+    );
+
+    void setCoilWaterHeaterCapacityPltSizNum(EnergyPlusData &state,
+                                             int const coilReportNum,
+                                             Real64 const totalHeatingCap, // {W} coil Heating capacity
+                                             bool const isAutoSize,        // true if value was autosized
+                                             int const dataPltSizNum,      // plant sizing structure index
+                                             int const dataWaterLoopNum    // plant loop structure index
+    );
+
+    void setCoilUA(EnergyPlusData &state,
+                   int const coilReportNum,
+                   Real64 const UAvalue,                   // [W/k] UA value for coil,
+                   Real64 const dataCapacityUsedForSizing, // [W] sizing global
+                   bool const isAutoSize,                  // true if value was autosized
+                   int const curSysNum,                    // airloop system number index, if non zero
+                   int const curZoneEqNum                  // zone equipment list index, if non-zero
+    );
+
+    void setCoilReheatMultiplier(EnergyPlusData &state,
+                                 int const coilReportNum,
+                                 Real64 const multiplierReheatLoad);
+
+    void setCoilSupplyFanInfo(EnergyPlusData &state,
+                              int const coilReportNum,
+                              std::string const &fanName,
+                              HVAC::FanType fanType,
+                              int fanIndex);
+
+    void setCoilEqNum(EnergyPlusData &state,
+                      int const curSysNum,
+                      int const curOASysNum,
+                      int const curZoneEqNum);
+  
+    std::string getTimeText(EnergyPlusData &state, int const timeStepAtPeak);
 
     bool isCompTypeFan(std::string const &compType // string component type, input object class name
     );
@@ -421,11 +576,10 @@ public: // methods
     bool isCompTypeCoil(std::string const &compType // string component type, input object class name
     );
 
-    void setZoneLatentLoadCoolingIdealPeak(int const zoneIndex, Real64 const zoneCoolingLatentLoad);
+    void setZoneLatentLoadCoolingIdealPeak(EnergyPlusData &state, int const zoneIndex, Real64 const zoneCoolingLatentLoad);
 
-    void setZoneLatentLoadHeatingIdealPeak(int const zoneIndex, Real64 const zoneHeatingLatentLoad);
+    void setZoneLatentLoadHeatingIdealPeak(EnergyPlusData &state, int const zoneIndex, Real64 const zoneHeatingLatentLoad);
 
-private: // methods
     void doAirLoopSetup(EnergyPlusData &state, int const coilVecIndex);
 
     void doZoneEqSetup(EnergyPlusData &state, int const coilVecIndex);
@@ -436,25 +590,18 @@ private: // methods
 
     void writeCoilSelectionOutput2(EnergyPlusData &state);
 
-    int getIndexForOrCreateDataObjFromCoilName(EnergyPlusData &state,
-                                               std::string const &coilName, // user-defined name of the coil
-                                               std::string const &coilType  // idf input object class name of coil
+    int getReportIndex(EnergyPlusData &state,
+                       std::string const &coilName, // user-defined name of the coil
+                       HVAC::CoilType const coilType  // idf input object class name of coil
     );
 
-    void associateZoneCoilWithParent(EnergyPlusData &state, std::unique_ptr<CoilSelectionData> &c);
-
-public: // data
-    int numCoilsReported_;
-    std::vector<std::unique_ptr<CoilSelectionData>> coilSelectionDataObjs;
-
-}; // end ReportCoilSelection class
-
-void createCoilSelectionReportObj(EnergyPlusData &state);
+    void associateZoneCoilWithParent(EnergyPlusData &state, CoilSelectionData *c);
 
+} // namespace ReportCoilSelection
+  
 struct ReportCoilSelectionData : BaseGlobalStruct
 {
-
-    std::unique_ptr<ReportCoilSelection> coilSelectionReportObj;
+    std::vector<ReportCoilSelection::CoilSelectionData*> coils;
 
     void init_constant_state([[maybe_unused]] EnergyPlusData &state) override
     {
@@ -466,7 +613,8 @@ struct ReportCoilSelectionData : BaseGlobalStruct
 
     void clear_state() override
     {
-        this->coilSelectionReportObj.release();
+        for (int i = 0; i < this->coils.size(); ++i) delete this->coils[i];
+        this->coils.clear();
     }
 };
 
diff --git a/src/EnergyPlus/SZVAVModel.cc b/src/EnergyPlus/SZVAVModel.cc
index 980e1376632..3c87b47c2e8 100644
--- a/src/EnergyPlus/SZVAVModel.cc
+++ b/src/EnergyPlus/SZVAVModel.cc
@@ -126,10 +126,10 @@ namespace SZVAVModel {
             maxAirMassFlow = SZVAVModel.MaxCoolAirMassFlow;
             lowSpeedFanRatio = SZVAVModel.LowSpeedCoolFanRatio;
             coilFluidInletNode = SZVAVModel.CoolCoilFluidInletNode;
-            coilFluidOutletNode = SZVAVModel.CoolCoilFluidOutletNodeNum;
+            coilFluidOutletNode = SZVAVModel.CoolCoilFluidOutletNode;
             coilPlantLoc = SZVAVModel.CoolCoilPlantLoc;
-            coilAirInletNode = SZVAVModel.CoolCoilInletNodeNum;
-            coilAirOutletNode = SZVAVModel.CoolCoilOutletNodeNum;
+            coilAirInletNode = SZVAVModel.CoolCoilAirInletNode;
+            coilAirOutletNode = SZVAVModel.CoolCoilAirOutletNode;
         } else if (HeatingLoad) {
             maxCoilFluidFlow = SZVAVModel.MaxHeatCoilFluidFlow;
             maxOutletTemp = SZVAVModel.DesignMaxOutletTemp;
@@ -137,10 +137,10 @@ namespace SZVAVModel {
             maxAirMassFlow = SZVAVModel.MaxHeatAirMassFlow;
             lowSpeedFanRatio = SZVAVModel.LowSpeedHeatFanRatio;
             coilFluidInletNode = SZVAVModel.HeatCoilFluidInletNode;
-            coilFluidOutletNode = SZVAVModel.HeatCoilFluidOutletNodeNum;
+            coilFluidOutletNode = SZVAVModel.HeatCoilFluidOutletNode;
             coilPlantLoc = SZVAVModel.HeatCoilPlantLoc;
-            coilAirInletNode = SZVAVModel.HeatCoilInletNodeNum;
-            coilAirOutletNode = SZVAVModel.HeatCoilOutletNodeNum;
+            coilAirInletNode = SZVAVModel.HeatCoilAirInletNode;
+            coilAirOutletNode = SZVAVModel.HeatCoilAirOutletNode;
         } else { // should never get here, protect against uninitialized variables
             maxCoilFluidFlow = 0.0;
             maxOutletTemp = 0.0;
@@ -301,7 +301,7 @@ namespace SZVAVModel {
                         PlantUtilities::SetComponentFlowRate(state, maxCoilFluidFlow, coilFluidInletNode, coilFluidOutletNode, coilPlantLoc);
 
                     if ((CoolingLoad && (TempSensOutput < ZoneLoad)) || (HeatingLoad && (TempSensOutput > ZoneLoad))) {
-                        if (SZVAVModel.HCoilType_Num == FanCoilUnits::HCoil::Water || !HeatingLoad) {
+                        if (SZVAVModel.heatCoilType == HVAC::CoilType::HeatingWater || !HeatingLoad) {
                             auto f = [&state, SysIndex, FirstHVACIteration, &SZVAVModel, ZoneLoad, coilFluidInletNode, maxCoilFluidFlow, AirMassFlow](
                                          Real64 const PLR) {
                                 return FanCoilUnits::CalcFanCoilWaterFlowResidual(state,
@@ -333,7 +333,7 @@ namespace SZVAVModel {
                     } else { // not enough capacity at this air flow rate. Unit does have enough capacity a full water/air, otherwise wouldn't be here
                         // this is different from the PTUnit and UnitarySys routines in this module
                         // find the water flow rate that meets the min load at region 1/2 boundary
-                        if (SZVAVModel.HCoilType_Num == FanCoilUnits::HCoil::Water || !HeatingLoad) {
+                        if (SZVAVModel.heatCoilType == HVAC::CoilType::HeatingWater || !HeatingLoad) {
                             auto f = // (AUTO_OK_LAMBDA)
                                 [&state, SysIndex, FirstHVACIteration, &SZVAVModel, ZoneLoad, coilFluidInletNode, maxCoilFluidFlow, minAirMassFlow](
                                     Real64 const PLR) {
@@ -382,7 +382,7 @@ namespace SZVAVModel {
                         }
                     }
                 } else { // too much capacity when coil off, could lower air flow rate here to meet load if air flow is above minimum
-                    if (SZVAVModel.HCoilType_Num == FanCoilUnits::HCoil::Water || !HeatingLoad) {
+                    if (SZVAVModel.heatCoilType == HVAC::CoilType::HeatingWater || !HeatingLoad) {
                         auto f2 = [&state, SysIndex, FirstHVACIteration, &SZVAVModel, ZoneLoad, coilFluidInletNode](Real64 const PLR) {
                             return FanCoilUnits::CalcFanCoilAirAndWaterFlowResidual(state,
                                                                                     PLR,
@@ -445,7 +445,7 @@ namespace SZVAVModel {
                 FanCoilUnits::Calc4PipeFanCoil(state, SysIndex, SZVAVModel.ControlZoneNum, FirstHVACIteration, TempSensOutput, PartLoadRatio);
                 if ((CoolingLoad && ZoneLoad < TempSensOutput) || (HeatingLoad && ZoneLoad > TempSensOutput)) {
                     // otherwise iterate on load
-                    if (SZVAVModel.HCoilType_Num == FanCoilUnits::HCoil::Water || !HeatingLoad) {
+                    if (SZVAVModel.heatCoilType == HVAC::CoilType::HeatingWater || !HeatingLoad) {
                         auto f = [&state, SysIndex, FirstHVACIteration, &SZVAVModel, ZoneLoad, coilFluidInletNode, maxCoilFluidFlow, maxAirMassFlow](
                                      Real64 const PLR) {
                             return FanCoilUnits::CalcFanCoilWaterFlowResidual(state,
@@ -471,7 +471,7 @@ namespace SZVAVModel {
                         MessagePrefix = "Step 3: ";
                     }
                 } else { // too much capacity at full air flow with coil off, operate coil and fan in unison
-                    if (SZVAVModel.HCoilType_Num == FanCoilUnits::HCoil::Water || !HeatingLoad) {
+                    if (SZVAVModel.heatCoilType == HVAC::CoilType::HeatingWater || !HeatingLoad) {
                         auto f2 = [&state, SysIndex, FirstHVACIteration, &SZVAVModel, ZoneLoad, coilFluidInletNode](Real64 const PLR) {
                             return FanCoilUnits::CalcFanCoilAirAndWaterFlowResidual(state,
                                                                                     PLR,
diff --git a/src/EnergyPlus/SimAirServingZones.cc b/src/EnergyPlus/SimAirServingZones.cc
index b481e3b2fa8..15e8cbb0436 100644
--- a/src/EnergyPlus/SimAirServingZones.cc
+++ b/src/EnergyPlus/SimAirServingZones.cc
@@ -266,14 +266,11 @@ void GetAirPathData(EnergyPlusData &state)
     using MixedAir::GetOASystemNumber;
     using NodeInputManager::GetNodeNums;
     using NodeInputManager::GetOnlySingleNode;
-    using WaterCoils::GetCoilWaterInletNode;
 
     // SUBROUTINE PARAMETER DEFINITIONS:
     constexpr std::string_view RoutineName("GetAirPathData: ");
 
-    auto &OutsideAirSys = state.dataAirLoop->OutsideAirSys;
     auto &AirLoopControlInfo = state.dataAirLoop->AirLoopControlInfo;
-
     // SUBROUTINE LOCAL VARIABLE DEFINITIONS
     int NumNumbers;                // number of numbers returned by GetObjectItem
     Array1D<Real64> Numbers;       // numbers (REAL(r64)s) returned by GetObjectItem
@@ -338,8 +335,6 @@ void GetAirPathData(EnergyPlusData &state)
     int OASysContListNum;        // index of the controller list of the OA Sys
     int OASysControllerNum;      // index of OA Sys simple controller in the air primary system controller lists
     bool NodeNotFound;           // true if matching actuator node not found
-    CompType CompType_Num;       // numeric equivalent for component type
-    std::string CompType;        // component type
     int WaterCoilNodeNum;        // numeric equivalent for water coil node number
     int ActuatorNodeNum;         // numeric equivalent for controller actuator node number
     Array1D_string MatchNodeName(3);
@@ -1087,10 +1082,11 @@ void GetAirPathData(EnergyPlusData &state)
                     WaterCoilNodeNum = -1;
                     // added to fix bug issue #5695, if HW coil on outdoor air system, don't lock out during economizing
                     if (OANum > 0) {
-                        for (int OACompNum = 1; OACompNum <= OutsideAirSys(OANum).NumComponents; ++OACompNum) {
-                            CompType = OutsideAirSys(OANum).ComponentType(OACompNum);
-                            if (Util::SameString(CompType, "Coil:Heating:Water")) {
-                                WaterCoilNodeNum = GetCoilWaterInletNode(state, CompType, OutsideAirSys(OANum).ComponentName(OACompNum), ErrorsFound);
+                        auto const &oaSys = state.dataAirLoop->OutsideAirSys(OANum);
+                        for (int OACompNum = 1; OACompNum <= oaSys.NumComponents; ++OACompNum) {
+                            if (Util::SameString(oaSys.ComponentType(OACompNum), "Coil:Heating:Water")) {
+                                int waterCoilNum = WaterCoils::GetCoilIndex(state, oaSys.ComponentName(OACompNum));
+                                WaterCoilNodeNum = WaterCoils::GetCoilWaterInletNode(state, waterCoilNum);
                                 if (WaterCoilNodeNum == ActuatorNodeNum) nonLockoutCoilFound = true;
                                 break;
                             }
@@ -1101,15 +1097,17 @@ void GetAirPathData(EnergyPlusData &state)
                         //         OA system controller list. The CanBeLockedOutByEcono should only be set for OA coils
                         //         First get the OA controller actuator node and then compare to the air loop coil water inlet node
                         //         If these node numbers match, the coil is in the main air loop and the lockout flag should be reset to FALSE
-                        for (BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
-                            for (CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
-                                if (Util::SameString(primaryAirSystems.Branch(BranchNum).Comp(CompNum).TypeOf, "AirloopHVAC:OutdoorAirSystem"))
+                        for (int BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
+                            auto const &branch = primaryAirSystems.Branch(BranchNum);
+                            for (int CompNum = 1; CompNum <= branch.TotalComponents; ++CompNum) {
+                                auto const &comp = branch.Comp(CompNum);
+                                // Just count how many times we are uppercasing strings here
+                                if (Util::SameString(comp.TypeOf, "AirloopHVAC:OutdoorAirSystem"))
                                     continue;
-                                CompType = primaryAirSystems.Branch(BranchNum).Comp(CompNum).TypeOf;
-                                if (Util::SameString(CompType, "Coil:Cooling:Water:DetailedGeometry") ||
-                                    Util::SameString(CompType, "Coil:Heating:Water") || Util::SameString(CompType, "Coil:Cooling:Water")) {
-                                    WaterCoilNodeNum =
-                                        GetCoilWaterInletNode(state, CompType, primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name, ErrorsFound);
+                                if (Util::SameString(comp.TypeOf, "Coil:Cooling:Water:DetailedGeometry") ||
+                                    Util::SameString(comp.TypeOf, "Coil:Heating:Water") || Util::SameString(comp.TypeOf, "Coil:Cooling:Water")) {
+                                    int waterCoilNum = WaterCoils::GetCoilIndex(state, comp.Name);
+                                    WaterCoilNodeNum = WaterCoils::GetCoilWaterInletNode(state, waterCoilNum);
                                     if (WaterCoilNodeNum == ActuatorNodeNum) {
                                         nonLockoutCoilFound = true;
                                         break;
@@ -1153,179 +1151,186 @@ void GetAirPathData(EnergyPlusData &state)
     lAlphaBlanks.deallocate();
 
     TestUniqueNodes.deallocate();
-    for (AirSysNum = 1; AirSysNum <= NumPrimaryAirSys; ++AirSysNum) {
+    for (int AirSysNum = 1; AirSysNum <= NumPrimaryAirSys; ++AirSysNum) {
         auto &primaryAirSystems = state.dataAirSystemsData->PrimaryAirSystems(AirSysNum);
-        for (BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
-            for (CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
+        for (int BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
+            for (int CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
+                auto &comp = primaryAirSystems.Branch(BranchNum).Comp(CompNum);
 
-                {
-                    std::string const componentType = uppercased(primaryAirSystems.Branch(BranchNum).Comp(CompNum).TypeOf);
-
-                    if (componentType == "AIRLOOPHVAC:OUTDOORAIRSYSTEM") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::OAMixer_Num;
+                if (comp.TypeOf == "AIRLOOPHVAC:OUTDOORAIRSYSTEM") {
+                    comp.compType = CompType::OAMixer;
 
-                        // Fan Types for the air sys simulation
-                    } else if (componentType == "FAN:CONSTANTVOLUME") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Fan_Simple_CV;
+                    // Fan Types for the air sys simulation
+                } else if (comp.TypeOf == "FAN:CONSTANTVOLUME") {
+                    comp.compType = CompType::Fan_Simple_CV;
 
-                    } else if (componentType == "FAN:VARIABLEVOLUME") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Fan_Simple_VAV;
+                } else if (comp.TypeOf == "FAN:VARIABLEVOLUME") {
+                    comp.compType = CompType::Fan_Simple_VAV;
 
-                    } else if (componentType == "FAN:SYSTEMMODEL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Fan_System_Object;
-                        auto &comp = primaryAirSystems.Branch(BranchNum).Comp(CompNum);
+                } else if (comp.TypeOf == "FAN:SYSTEMMODEL") {
+                    comp.compType = CompType::Fan_System_Object;
+                    if (comp.CompIndex == 0) {
+                        comp.CompIndex = Fans::GetFanIndex(state, comp.Name); // TODO: get rid of this
                         if (comp.CompIndex == 0) {
-                            comp.CompIndex = Fans::GetFanIndex(state, comp.Name); // TODO: get rid of this
-                            if (comp.CompIndex == 0) {
-                                ShowSevereError(state, format("Component {} of type {} not found.", comp.Name, comp.TypeOf));
-                            }
+                            ShowSevereError(state, format("Component {} of type {} not found.", comp.Name, comp.TypeOf));
                         }
+                    }
+                    
+                    state.dataFans->fans(comp.CompIndex)->airPathFlag = true;
+                } else if (comp.TypeOf == "FAN:COMPONENTMODEL") {
+                    comp.compType = CompType::Fan_ComponentModel;
+
+                    // Coil Types for the air sys simulation
+                    //        HX Assisted coils are not allowed on a branch at this time
+                    //        CASE('COILSYSTEM:COOLING:DX:HEATEXCHANGERASSISTED')
+                    //          PrimaryAirSystem(AirSysNum)%Branch(BranchNum)%Comp(CompNum)%CompType_Num=DXCoil_CoolingHXAsst
+                } else if (comp.TypeOf == "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED") {
+                    comp.compType = CompType::WaterCoil_CoolingHXAsst;
+                } else if (comp.TypeOf == "COIL:HEATING:WATER") {
+                    comp.compType = CompType::WaterCoil_SimpleHeat;
+                } else if (comp.TypeOf == "COIL:HEATING:STEAM") {
+                    comp.compType = CompType::SteamCoil_AirHeat;
+                } else if (comp.TypeOf == "COIL:COOLING:WATER:DETAILEDGEOMETRY") {
+                    comp.compType = CompType::WaterCoil_DetailedCool;
+                } else if (comp.TypeOf == "COIL:COOLING:WATER") {
+                    comp.compType = CompType::WaterCoil_Cooling;
+                } else if (comp.TypeOf == "COIL:HEATING:ELECTRIC") {
+                    comp.compType = CompType::Coil_ElectricHeat;
+                } else if (comp.TypeOf == "COIL:HEATING:FUEL") {
+                    comp.compType = CompType::Coil_GasHeat;
+
+                // Heat reclaim
+                } else if (comp.TypeOf == "COIL:HEATING:DESUPERHEATER") {
+                    comp.compType = CompType::Coil_DeSuperHeat;
+
+                } else if (comp.TypeOf == "COILSYSTEM:COOLING:DX") {
+                    comp.compType = CompType::DXSystem;
+                } else if (comp.TypeOf == "COILSYSTEM:HEATING:DX") {
+                    comp.compType = CompType::DXHeatPumpSystem;
+                } else if (comp.TypeOf == "COIL:USERDEFINED") {
+                    comp.compType = CompType::CoilUserDefined;
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARYSYSTEM") {
+                    comp.compType = CompType::UnitarySystemModel;
+                    UnitarySystems::UnitarySys thisSys;
+                    comp.compPointer = thisSys.factory(state, HVAC::UnitarySysType::Unitary_AnyCoilType, comp.Name, false, 0);
+                } else if (comp.TypeOf == "COILSYSTEM:COOLING:WATER") {
+                    comp.compType = CompType::CoilSystemWater;
+                    UnitarySystems::UnitarySys thisSys;
+                    comp.compPointer = thisSys.factory(state, HVAC::UnitarySysType::Unitary_AnyCoilType, comp.Name, false, 0);
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARY:FURNACE:HEATONLY") {
+                    comp.compType = CompType::Furnace_UnitarySys_HeatOnly;
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARY:FURNACE:HEATCOOL") {
+                    comp.compType = CompType::Furnace_UnitarySys_HeatCool;
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARYHEATONLY") {
+                    comp.compType = CompType::Furnace_UnitarySys_HeatOnly;
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARYHEATCOOL") {
+                    comp.compType = CompType::Furnace_UnitarySys_HeatCool;
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARYHEATPUMP:AIRTOAIR") {
+                    comp.compType = CompType::Furnace_UnitarySys_HeatCool;
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARYHEATPUMP:WATERTOAIR") {
+                    comp.compType = CompType::Furnace_UnitarySys_HeatCool;
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARYHEATCOOL:VAVCHANGEOVERBYPASS") {
+                    comp.compType = CompType::UnitarySystem_BypassVAVSys;
+
+                    // Humidifier Types for the air system simulation
+                } else if (comp.TypeOf == "HUMIDIFIER:STEAM:ELECTRIC") {
+                    comp.compType = CompType::Humidifier;
+
+                } else if (comp.TypeOf == "HUMIDIFIER:STEAM:GAS") {
+                    comp.compType = CompType::Humidifier;
+
+                    // Evap Cooler Types for the air system simulation
+                } else if (comp.TypeOf == "EVAPORATIVECOOLER:DIRECT:CELDEKPAD") {
+                    comp.compType = CompType::EvapCooler;
+                } else if (comp.TypeOf == "EVAPORATIVECOOLER:INDIRECT:CELDEKPAD") {
+                    comp.compType = CompType::EvapCooler;
+                } else if (comp.TypeOf == "EVAPORATIVECOOLER:INDIRECT:WETCOIL") {
+                    comp.compType = CompType::EvapCooler;
+                } else if (comp.TypeOf == "EVAPORATIVECOOLER:INDIRECT:RESEARCHSPECIAL") {
+                    comp.compType = CompType::EvapCooler;
+                } else if (comp.TypeOf == "EVAPORATIVECOOLER:DIRECT:RESEARCHSPECIAL") {
+                    comp.compType = CompType::EvapCooler;
+
+                  // Desiccant Dehumidifier Types for the air system simulation
+                } else if (comp.TypeOf == "DEHUMIDIFIER:DESICCANT:NOFANS") {
+                    comp.compType = CompType::Desiccant;
+                } else if (comp.TypeOf == "DEHUMIDIFIER:DESICCANT:SYSTEM") {
+                    comp.compType = CompType::Desiccant;
+
+                    // Heat recovery
+                } else if (comp.TypeOf == "HEATEXCHANGER:AIRTOAIR:FLATPLATE") {
+                    comp.compType = CompType::HeatXchngr;
+                } else if (comp.TypeOf == "HEATEXCHANGER:AIRTOAIR:SENSIBLEANDLATENT") {
+                    comp.compType = CompType::HeatXchngr;
+                } else if (comp.TypeOf == "HEATEXCHANGER:DESICCANT:BALANCEDFLOW") {
+                    comp.compType = CompType::HeatXchngr;
+
+                    // Ducts
+                } else if (comp.TypeOf == "DUCT") {
+                    comp.compType = CompType::Duct;
+
+                } else if (comp.TypeOf == "AIRLOOPHVAC:UNITARYHEATPUMP:AIRTOAIR:MULTISPEED") {
+                    comp.compType = CompType::UnitarySystem_MSHeatPump;
+                } else if (comp.TypeOf == "ZONEHVAC:TERMINALUNIT:VARIABLEREFRIGERANTFLOW") {
+                    comp.compType = CompType::ZoneVRFasAirLoopEquip;
+                } else if (comp.TypeOf == "FAN:ONOFF" || comp.TypeOf == "COIL:COOLING:DX:SINGLESPEED" ||
+                           comp.TypeOf == "COIL:HEATING:DX:SINGLESPEED" || comp.TypeOf == "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE" ||
+                           comp.TypeOf == "COIL:COOLING:DX:MULTISPEED" || comp.TypeOf == "COIL:HEATING:DX:MULTISPEED") {
+                    ShowSevereError(state, format("{}{} = \"{}\".", RoutineName, CurrentModuleObject, primaryAirSystems.Name));
+                    ShowContinueError(state, format("..Invalid Air Loop Component Type = \"{}\".", comp.TypeOf));
+                    ShowContinueError(state, format("..Air Loop Component Name = \"{}\".", comp.Name));
+                    ShowContinueError(state, format("..reference Branch = \"{}\".", primaryAirSystems.Branch(BranchNum).Name));
+                    ShowContinueError(state,
+                                      "...This component may only be referenced by a parent component such as "
+                                      "AirLoopHVAC:Unitary:Furnace:HeatCool or similar.");
+                    ErrorsFound = true;
+                    
+                } else {
+                    ShowSevereError(state, format("{}{} = \"{}\".", RoutineName, CurrentModuleObject, primaryAirSystems.Name));
+                    ShowContinueError(state, format("..Invalid Air Loop Component Type = \"{}\".", comp.TypeOf));
+                    ShowContinueError(state,
+                                      format("..Air Loop Component Name = \"{}\".", comp.Name));
+                    ShowContinueError(state, format("..reference Branch = \"{}\".", primaryAirSystems.Branch(BranchNum).Name));
+                    ErrorsFound = true;
+                }
 
-                        state.dataFans->fans(comp.CompIndex)->airPathFlag = true;
-                    } else if (componentType == "FAN:COMPONENTMODEL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Fan_ComponentModel;
-
-                        // Coil Types for the air sys simulation
-                        //        HX Assisted coils are not allowed on a branch at this time
-                        //        CASE('COILSYSTEM:COOLING:DX:HEATEXCHANGERASSISTED')
-                        //          PrimaryAirSystem(AirSysNum)%Branch(BranchNum)%Comp(CompNum)%CompType_Num=DXCoil_CoolingHXAsst
-                    } else if (componentType == "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::WaterCoil_CoolingHXAsst;
-                    } else if (componentType == "COIL:HEATING:WATER") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::WaterCoil_SimpleHeat;
-                    } else if (componentType == "COIL:HEATING:STEAM") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::SteamCoil_AirHeat;
-                    } else if (componentType == "COIL:COOLING:WATER:DETAILEDGEOMETRY") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::WaterCoil_DetailedCool;
-                    } else if (componentType == "COIL:COOLING:WATER") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::WaterCoil_Cooling;
-                    } else if (componentType == "COIL:HEATING:ELECTRIC") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Coil_ElectricHeat;
-                    } else if (componentType == "COIL:HEATING:FUEL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Coil_GasHeat;
-
-                        // Heat reclaim
-                    } else if (componentType == "COIL:HEATING:DESUPERHEATER") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Coil_DeSuperHeat;
-
-                    } else if (componentType == "COILSYSTEM:COOLING:DX") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::DXSystem;
-                    } else if (componentType == "COILSYSTEM:HEATING:DX") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::DXHeatPumpSystem;
-                    } else if (componentType == "COIL:USERDEFINED") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::CoilUserDefined;
-                    } else if (componentType == "AIRLOOPHVAC:UNITARYSYSTEM") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::UnitarySystemModel;
-                        UnitarySystems::UnitarySys thisSys;
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).compPointer = thisSys.factory(
-                            state, HVAC::UnitarySysType::Unitary_AnyCoilType, primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name, false, 0);
-                    } else if (componentType == "COILSYSTEM:COOLING:WATER") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::CoilSystemWater;
-                        UnitarySystems::UnitarySys thisSys;
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).compPointer = thisSys.factory(
-                            state, HVAC::UnitarySysType::Unitary_AnyCoilType, primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name, false, 0);
-                    } else if (componentType == "AIRLOOPHVAC:UNITARY:FURNACE:HEATONLY") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Furnace_UnitarySys_HeatOnly;
-                    } else if (componentType == "AIRLOOPHVAC:UNITARY:FURNACE:HEATCOOL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Furnace_UnitarySys_HeatCool;
-                    } else if (componentType == "AIRLOOPHVAC:UNITARYHEATONLY") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Furnace_UnitarySys_HeatOnly;
-                    } else if (componentType == "AIRLOOPHVAC:UNITARYHEATCOOL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Furnace_UnitarySys_HeatCool;
-                    } else if (componentType == "AIRLOOPHVAC:UNITARYHEATPUMP:AIRTOAIR") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Furnace_UnitarySys_HeatCool;
-                    } else if (componentType == "AIRLOOPHVAC:UNITARYHEATPUMP:WATERTOAIR") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Furnace_UnitarySys_HeatCool;
-
-                    } else if (componentType == "AIRLOOPHVAC:UNITARYHEATCOOL:VAVCHANGEOVERBYPASS") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::UnitarySystem_BypassVAVSys;
-
-                        // Humidifier Types for the air system simulation
-                    } else if (componentType == "HUMIDIFIER:STEAM:ELECTRIC") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Humidifier;
-
-                    } else if (componentType == "HUMIDIFIER:STEAM:GAS") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Humidifier;
-
-                        // Evap Cooler Types for the air system simulation
-                    } else if (componentType == "EVAPORATIVECOOLER:DIRECT:CELDEKPAD") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::EvapCooler;
-                    } else if (componentType == "EVAPORATIVECOOLER:INDIRECT:CELDEKPAD") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::EvapCooler;
-                    } else if (componentType == "EVAPORATIVECOOLER:INDIRECT:WETCOIL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::EvapCooler;
-                    } else if (componentType == "EVAPORATIVECOOLER:INDIRECT:RESEARCHSPECIAL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::EvapCooler;
-                    } else if (componentType == "EVAPORATIVECOOLER:DIRECT:RESEARCHSPECIAL") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::EvapCooler;
-
-                        // Desiccant Dehumidifier Types for the air system simulation
-                    } else if (componentType == "DEHUMIDIFIER:DESICCANT:NOFANS") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Desiccant;
-                    } else if (componentType == "DEHUMIDIFIER:DESICCANT:SYSTEM") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Desiccant;
-
-                        // Heat recovery
-                    } else if (componentType == "HEATEXCHANGER:AIRTOAIR:FLATPLATE") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::HeatXchngr;
-
-                    } else if (componentType == "HEATEXCHANGER:AIRTOAIR:SENSIBLEANDLATENT") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::HeatXchngr;
-
-                    } else if (componentType == "HEATEXCHANGER:DESICCANT:BALANCEDFLOW") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::HeatXchngr;
-
-                        // Ducts
-                    } else if (componentType == "DUCT") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::Duct;
-
-                    } else if (componentType == "AIRLOOPHVAC:UNITARYHEATPUMP:AIRTOAIR:MULTISPEED") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::UnitarySystem_MSHeatPump;
-
-                    } else if (componentType == "ZONEHVAC:TERMINALUNIT:VARIABLEREFRIGERANTFLOW") {
-                        primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num = CompType::ZoneVRFasAirLoopEquip;
-
-                    } else if (componentType == "FAN:ONOFF" || componentType == "COIL:COOLING:DX:SINGLESPEED" ||
-                               componentType == "COIL:HEATING:DX:SINGLESPEED" || componentType == "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE" ||
-                               componentType == "COIL:COOLING:DX:MULTISPEED" || componentType == "COIL:HEATING:DX:MULTISPEED") {
-                        ShowSevereError(state, format("{}{} = \"{}\".", RoutineName, CurrentModuleObject, primaryAirSystems.Name));
-                        ShowContinueError(
-                            state, format("..Invalid Air Loop Component Type = \"{}\".", primaryAirSystems.Branch(BranchNum).Comp(CompNum).TypeOf));
-                        ShowContinueError(state,
-                                          format("..Air Loop Component Name = \"{}\".", primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name));
-                        ShowContinueError(state, format("..reference Branch = \"{}\".", primaryAirSystems.Branch(BranchNum).Name));
-                        ShowContinueError(state,
-                                          "...This component may only be referenced by a parent component such as "
-                                          "AirLoopHVAC:Unitary:Furnace:HeatCool or similar.");
-                        ErrorsFound = true;
-
-                    } else {
-                        ShowSevereError(state, format("{}{} = \"{}\".", RoutineName, CurrentModuleObject, primaryAirSystems.Name));
-                        ShowContinueError(
-                            state, format("..Invalid Air Loop Component Type = \"{}\".", primaryAirSystems.Branch(BranchNum).Comp(CompNum).TypeOf));
-                        ShowContinueError(state,
-                                          format("..Air Loop Component Name = \"{}\".", primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name));
-                        ShowContinueError(state, format("..reference Branch = \"{}\".", primaryAirSystems.Branch(BranchNum).Name));
-                        ErrorsFound = true;
+                if (comp.compType == CompType::WaterCoil_Cooling ||
+                    comp.compType == CompType::WaterCoil_DetailedCool ||
+                    comp.compType == CompType::WaterCoil_SimpleHeat) {
+                    comp.CompIndex = WaterCoils::GetCoilIndex(state, comp.Name);
+                    if (comp.CompIndex == 0) {
+                        ShowSevereError(state, format("Component {} of type {} not found.", comp.Name, comp.TypeOf));
+                    }
+                } else if (comp.compType == CompType::SteamCoil_AirHeat) {
+                   comp.CompIndex = SteamCoils::GetCoilIndex(state, comp.Name);
+                    if (comp.CompIndex == 0) {
+                        ShowSevereError(state, format("Component {} of type {} not found.", comp.Name, comp.TypeOf));
+                    }
+                } else if (comp.compType == CompType::Coil_ElectricHeat ||
+                           comp.compType == CompType::Coil_GasHeat ||
+                           comp.compType == CompType::Coil_DeSuperHeat) {
+                    comp.CompIndex = HeatingCoils::GetCoilIndex(state, comp.Name);
+                    if (comp.CompIndex == 0) {
+                        ShowSevereError(state, format("Component {} of type {} not found.", comp.Name, comp.TypeOf));
                     }
                 }
+                
             }
         }
     }
 
     // check that actuator nodes are matched by a water coil inlet node
 
-    for (AirSysNum = 1; AirSysNum <= NumPrimaryAirSys; ++AirSysNum) {
+    for (int AirSysNum = 1; AirSysNum <= NumPrimaryAirSys; ++AirSysNum) {
         auto &primaryAirSystems = state.dataAirSystemsData->PrimaryAirSystems(AirSysNum);
-        for (BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
-            for (CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
-                CompType_Num = primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num;
-                if (CompType_Num == CompType::WaterCoil_DetailedCool || CompType_Num == CompType::WaterCoil_SimpleHeat ||
-                    CompType_Num == CompType::WaterCoil_Cooling) {
-                    WaterCoilNodeNum = GetCoilWaterInletNode(state,
-                                                             primaryAirSystems.Branch(BranchNum).Comp(CompNum).TypeOf,
-                                                             primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name,
-                                                             ErrorsFound);
+        for (int BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
+            for (int CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
+                auto &comp = primaryAirSystems.Branch(BranchNum).Comp(CompNum);
+                if (comp.compType == CompType::WaterCoil_DetailedCool ||
+                    comp.compType == CompType::WaterCoil_SimpleHeat ||
+                    comp.compType == CompType::WaterCoil_Cooling) {
+                    int waterCoilNum = WaterCoils::GetCoilIndex(state, comp.Name);
+                    WaterCoilNodeNum = WaterCoils::GetCoilWaterInletNode(state, waterCoilNum);
                     CheckCoilWaterInletNode(state, WaterCoilNodeNum, NodeNotFound);
                     if (NodeNotFound) {
                         ErrorsFound = true;
@@ -1333,7 +1338,7 @@ void GetAirPathData(EnergyPlusData &state)
                                         format("{}{}=\"{}\", invalid actuator.",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name));
+                                               comp.Name));
                         ShowContinueError(state,
                                           "...this coil requires a water coil controller and the inlet node of a water coil must also be an "
                                           "actuator node of a water coil controller.");
@@ -1343,29 +1348,6 @@ void GetAirPathData(EnergyPlusData &state)
         }
     }
 
-    OANum = GetNumOASystems(state);
-    for (int OASysNum = 1; OASysNum <= OANum; ++OASysNum) {
-        int NumInList = GetOACompListNumber(state, OASysNum);
-        for (int OACompNum = 1; OACompNum <= NumInList; ++OACompNum) {
-            CompType_Num = GetOACompTypeNum(state, OASysNum, OACompNum);
-            if (CompType_Num == CompType::WaterCoil_DetailedCool || CompType_Num == CompType::WaterCoil_SimpleHeat ||
-                CompType_Num == CompType::WaterCoil_Cooling) {
-                WaterCoilNodeNum =
-                    GetCoilWaterInletNode(state, GetOACompType(state, OASysNum, OACompNum), GetOACompName(state, OASysNum, OACompNum), ErrorsFound);
-                CheckCoilWaterInletNode(state, WaterCoilNodeNum, NodeNotFound);
-                UnitarySystems::isWaterCoilHeatRecoveryType(state, WaterCoilNodeNum, NodeNotFound);
-                if (NodeNotFound) {
-                    ErrorsFound = true;
-                    ShowSevereError(
-                        state, format("{}{}=\"{}\", invalid actuator.", RoutineName, CurrentModuleObject, GetOACompName(state, OASysNum, OACompNum)));
-                    ShowContinueError(state,
-                                      "...this coil requires a water coil controller and the inlet node of a water coil must also be an actuator "
-                                      "node of a water coil controller.");
-                }
-            }
-        }
-    }
-
     if (ErrorsFound) {
         ShowFatalError(state, format("{}Errors found retrieving input for {}.", RoutineName, CurrentModuleObject));
     }
@@ -1929,8 +1911,8 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE
 
                 for (int CompNum = 1; CompNum <= branch.TotalComponents; ++CompNum) {
                     auto &comp = branch.Comp(CompNum);
-                    CompType compType = comp.CompType_Num;
-                    if (compType == CompType::OAMixer_Num) {
+                    CompType compType = comp.compType;
+                    if (compType == CompType::OAMixer) {
                         FoundOASys = true;
                     } else if (compType == CompType::WaterCoil_Cooling || compType == CompType::WaterCoil_DetailedCool ||
                                compType == CompType::WaterCoil_CoolingHXAsst || compType == CompType::DXSystem) {
@@ -1983,7 +1965,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE
             for (int BranchNum = 1; !FoundCentralHeatCoil && BranchNum <= thisPrimaryAirSys.NumBranches; ++BranchNum) {
                 for (int CompNum = 1; !FoundCentralHeatCoil && CompNum <= thisPrimaryAirSys.Branch(BranchNum).TotalComponents; ++CompNum) {
                     std::string &CompName = thisPrimaryAirSys.Branch(BranchNum).Comp(CompNum).Name;
-                    CompType CompTypeNum = thisPrimaryAirSys.Branch(BranchNum).Comp(CompNum).CompType_Num;
+                    CompType CompTypeNum = thisPrimaryAirSys.Branch(BranchNum).Comp(CompNum).compType;
                     switch (CompTypeNum) {
                     case CompType::WaterCoil_SimpleHeat:
                     case CompType::Coil_ElectricHeat:
@@ -2021,7 +2003,7 @@ void InitAirLoops(EnergyPlusData &state, bool const FirstHVACIteration) // TRUE
             bool unitaryHeatingCoilExists = false;
             for (int BranchNum = 1; !FoundCentralCoolCoil && BranchNum <= thisPrimaryAirSys.NumBranches; ++BranchNum) {
                 for (int CompNum = 1; !FoundCentralCoolCoil && CompNum <= thisPrimaryAirSys.Branch(BranchNum).TotalComponents; ++CompNum) {
-                    CompType CompTypeNum = thisPrimaryAirSys.Branch(BranchNum).Comp(CompNum).CompType_Num;
+                    CompType CompTypeNum = thisPrimaryAirSys.Branch(BranchNum).Comp(CompNum).compType;
                     std::string &CompName = thisPrimaryAirSys.Branch(BranchNum).Comp(CompNum).Name;
                     switch (CompTypeNum) {
                     case CompType::WaterCoil_Cooling:
@@ -3028,8 +3010,6 @@ void SolveWaterCoilController(EnergyPlusData &state,
     using namespace DataHVACControllers;
     using General::CreateSysTimeIntervalString;
     using HVACControllers::ManageControllers;
-    using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil;
-    using WaterCoils::SimulateWaterCoilComponents;
 
     // Locals
     // SUBROUTINE ARGUMENT DEFINITIONS:
@@ -3097,9 +3077,9 @@ void SolveWaterCoilController(EnergyPlusData &state,
 
     // Evaluate water coils with new actuated variables
     if (HXAssistedWaterCoil) {
-        SimHXAssistedCoolingCoil(state, CompName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, CompIndex, HVAC::FanOp::Continuous);
+        HXAssistCoil::SimHXAssistedCoolingCoil(state, CompName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, CompIndex, HVAC::FanOp::Continuous);
     } else {
-        SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex);
+        WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex);
     }
     IsUpToDateFlag = true;
 
@@ -3175,9 +3155,9 @@ void SolveWaterCoilController(EnergyPlusData &state,
 
             // Re-evaluate air loop components with new actuated variables
             if (HXAssistedWaterCoil) {
-                SimHXAssistedCoolingCoil(state, CompName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, CompIndex, HVAC::FanOp::Continuous);
+                HXAssistCoil::SimHXAssistedCoolingCoil(state, CompName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, CompIndex, HVAC::FanOp::Continuous);
             } else {
-                SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex);
+                WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex);
             }
             IsUpToDateFlag = true;
         }
@@ -3352,18 +3332,19 @@ void SimAirLoopComponents(EnergyPlusData &state,
 
         // Loop over components in branch
         for (int CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
+            auto &comp = state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum);
             // CompType = PrimaryAirSystem( AirLoopNum ).Branch( BranchNum ).Comp( CompNum ).TypeOf;
             // CompName = PrimaryAirSystem( AirLoopNum ).Branch( BranchNum ).Comp( CompNum ).Name;
-            CompType CompType_Num = primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num;
+            CompType CompType_Num = comp.compType;
 
             // Simulate each component on PrimaryAirSystem(AirLoopNum)%Branch(BranchNum)%Name
             SimAirLoopComponent(state,
-                                primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name,
+                                comp.Name,
                                 CompType_Num,
                                 FirstHVACIteration,
                                 AirLoopNum,
-                                primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompIndex,
-                                primaryAirSystems.Branch(BranchNum).Comp(CompNum).compPointer,
+                                comp.CompIndex,
+                                comp.compPointer,
                                 AirLoopNum,
                                 BranchNum,
                                 CompNum);
@@ -3409,18 +3390,14 @@ void SimAirLoopComponent(EnergyPlusData &state,
     using DesiccantDehumidifiers::SimDesiccantDehumidifier;
     using EvaporativeCoolers::SimEvapCooler;
     using Furnaces::SimFurnace;
-    using HeatingCoils::SimulateHeatingCoilComponents;
     using HeatRecovery::SimHeatRecovery;
     using Humidifiers::SimHumidifier;
     using HVACDuct::SimDuct;
     using HVACDXHeatPumpSystem::SimDXHeatPumpSystem;
-    using HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil;
     using HVACMultiSpeedHeatPump::SimMSHeatPump;
     using HVACUnitaryBypassVAV::SimUnitaryBypassVAV;
     using MixedAir::ManageOutsideAirSystem;
-    using SteamCoils::SimulateSteamCoilComponents;
     using UserDefinedComponents::SimCoilUserDefined;
-    using WaterCoils::SimulateWaterCoilComponents;
 
     // SUBROUTINE LOCAL VARIABLE DEFINITIONS:
     Real64 QActual;
@@ -3433,7 +3410,7 @@ void SimAirLoopComponent(EnergyPlusData &state,
     auto &airLoopControlInfo = state.dataAirLoop->AirLoopControlInfo(AirLoopNum);
 
     switch (CompType_Num) {
-    case CompType::OAMixer_Num: { // 'OUTSIDE AIR SYSTEM'
+    case CompType::OAMixer: { // 'OUTSIDE AIR SYSTEM'
         ManageOutsideAirSystem(state, CompName, FirstHVACIteration, AirLoopNum, CompIndex);
         // Fan Types for the air sys simulation
     } break;
@@ -3451,7 +3428,7 @@ void SimAirLoopComponent(EnergyPlusData &state,
     } break;
 
     case CompType::WaterCoil_CoolingHXAsst: { // 'CoilSystem:Cooling:Water:HeatExchangerAssisted'
-        SimHXAssistedCoolingCoil(state,
+        HXAssistCoil::SimHXAssistedCoolingCoil(state,
                                  CompName,
                                  FirstHVACIteration,
                                  HVAC::CompressorOp::On,
@@ -3465,34 +3442,26 @@ void SimAirLoopComponent(EnergyPlusData &state,
         if (QActual > 0.0) CoolingActive = true; // determine if coil is ON
     } break;
     case CompType::WaterCoil_SimpleHeat: { // 'Coil:Heating:Water'
-        SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex, QActual);
+        WaterCoils::SimulateWaterCoilComponents(state, CompIndex, FirstHVACIteration, QActual);
         if (QActual > 0.0) HeatingActive = true; // determine if coil is ON
     } break;
     case CompType::SteamCoil_AirHeat: { // 'Coil:Heating:Steam'
-        SimulateSteamCoilComponents(state, CompName, FirstHVACIteration, CompIndex, DataPrecisionGlobals::constant_zero, QActual);
+        SteamCoils::SimulateSteamCoilComponents(state, CompIndex, FirstHVACIteration, 0.0, QActual);
         if (QActual > 0.0) HeatingActive = true; // determine if coil is ON
     } break;
     case CompType::WaterCoil_DetailedCool: { // 'Coil:Cooling:Water:DetailedGeometry'
-        SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex, QActual);
+        WaterCoils::SimulateWaterCoilComponents(state, CompIndex, FirstHVACIteration, QActual);
         if (QActual > 0.0) CoolingActive = true; // determine if coil is ON
     } break;
     case CompType::WaterCoil_Cooling: { // 'Coil:Cooling:Water'
-        SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex, QActual);
+        WaterCoils::SimulateWaterCoilComponents(state, CompIndex, FirstHVACIteration, QActual);
         if (QActual > 0.0) CoolingActive = true; // determine if coil is ON
         // stand-alone coils are temperature controlled (do not pass QCoilReq in argument list, QCoilReq overrides temp SP)
     } break;
-    case CompType::Coil_ElectricHeat: { // 'Coil:Heating:Electric'
-        SimulateHeatingCoilComponents(state, CompName, FirstHVACIteration, _, CompIndex, QActual);
-        if (QActual > 0.0) HeatingActive = true; // determine if coil is ON
-        // stand-alone coils are temperature controlled (do not pass QCoilReq in argument list, QCoilReq overrides temp SP)
-    } break;
-    case CompType::Coil_GasHeat: { // 'Coil:Heating:Fuel'
-        SimulateHeatingCoilComponents(state, CompName, FirstHVACIteration, _, CompIndex, QActual);
-        if (QActual > 0.0) HeatingActive = true; // determine if coil is ON
-        // stand-alone coils are temperature controlled (do not pass QCoilReq in argument list, QCoilReq overrides temp SP)
-    } break;
+    case CompType::Coil_ElectricHeat: // 'Coil:Heating:Electric'
+    case CompType::Coil_GasHeat: // 'Coil:Heating:Fuel'
     case CompType::Coil_DeSuperHeat: { // 'Coil:Heating:Desuperheater' - heat reclaim
-        SimulateHeatingCoilComponents(state, CompName, FirstHVACIteration, _, CompIndex, QActual);
+        HeatingCoils::SimulateHeatingCoilComponents(state, CompIndex, FirstHVACIteration, _, QActual);
         if (QActual > 0.0) HeatingActive = true; // determine if coil is ON
     } break;
     case CompType::DXSystem: { // CoilSystem:Cooling:DX  old 'AirLoopHVAC:UnitaryCoolOnly'
@@ -3587,7 +3556,7 @@ void SimAirLoopComponent(EnergyPlusData &state,
         // Desiccant Dehumidifier Types for the air system simulation
     } break;
     case CompType::Desiccant: { // 'Dehumidifier:Desiccant:NoFans', 'Dehumidifier:Desiccant:System'
-        SimDesiccantDehumidifier(state, CompName, FirstHVACIteration, CompIndex);
+        DesiccantDehumidifiers::SimDesiccantDehumidifier(state, CompName, FirstHVACIteration, CompIndex);
         // Heat recovery
     } break;
     case CompType::HeatXchngr: { // 'HeatExchanger:AirToAir:FlatPlate', 'HeatExchanger:AirToAir:SensibleAndLatent'
@@ -3982,9 +3951,6 @@ void SizeAirLoopBranches(EnergyPlusData &state, int const AirLoopNum, int const
 
     // Using/Aliasing
     using namespace DataSizing;
-    using HVACHXAssistedCoolingCoil::GetHXCoilType;
-    using HVACHXAssistedCoolingCoil::GetHXDXCoilName;
-    using WaterCoils::SetCoilDesFlow;
 
     std::string CompType; // Component type
     std::string CompName; // Component name
@@ -4054,17 +4020,24 @@ void SizeAirLoopBranches(EnergyPlusData &state, int const AirLoopNum, int const
     for (CompNum = 1; CompNum <= PrimaryAirSystems(AirLoopNum).Branch(BranchNum).TotalComponents; ++CompNum) {
         CompType = PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).TypeOf;
         CompName = PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).Name;
-        CompType_Num = PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).CompType_Num;
+        CompType_Num = PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).compType;
         if (CompType_Num == CompType::WaterCoil_DetailedCool || CompType_Num == CompType::WaterCoil_SimpleHeat ||
             CompType_Num == CompType::WaterCoil_CoolingHXAsst) {
             if (CompType_Num == CompType::WaterCoil_CoolingHXAsst) {
-                CoilName = GetHXDXCoilName(state, CompType, CompName, ErrorsFound);
-                CoilType = GetHXCoilType(state, CompType, CompName, ErrorsFound);
+                int coilNum = HXAssistCoil::GetCoilIndex(state, CompName);
+                if (coilNum == 0) {
+                    ShowSevereError(state, format("Component not found {} = {}", CompType, CompName));
+                    ErrorsFound = true;
+                } else {
+                    CoilName = HXAssistCoil::GetCoilChildCoilName(state, coilNum);
+                    CoilType = HVAC::coilTypeNames[(int)HXAssistCoil::GetCoilChildCoilType(state, coilNum)];
+                }
             } else {
                 CoilName = CompName;
                 CoilType = CompType;
             }
-            SetCoilDesFlow(state, CoilType, CoilName, PrimaryAirSystems(AirLoopNum).DesignVolFlowRate, ErrorsFound);
+            int waterCoilNum = WaterCoils::GetCoilIndex(state, CoilName); 
+            WaterCoils::SetCoilDesFlow(state, waterCoilNum, PrimaryAirSystems(AirLoopNum).DesignVolFlowRate);
         }
     } // End of component loop
     if (ErrorsFound) {
@@ -7411,7 +7384,7 @@ Real64 GetHeatingSATempHumRatForSizing(EnergyPlusData &state, int const IndexAir
 
 void CheckWaterCoilIsOnAirLoop(EnergyPlusData &state,
                                SimAirServingZones::CompType const CompTypeNum,
-                               std::string const &CompType,
+                               HVAC::CoilType const coilType,
                                std::string const &CompName,
                                bool &WaterCoilOnAirLoop)
 {
@@ -7432,7 +7405,7 @@ void CheckWaterCoilIsOnAirLoop(EnergyPlusData &state,
         CheckWaterCoilIsOnAirLoop = CheckWaterCoilSystemOnAirLoopOrOASystem(state, CompTypeNum, CompName);
     }
     if (!CheckWaterCoilIsOnAirLoop) {
-        ShowSevereError(state, format("CheckWaterCoilIsOnAirLoop: = {} = {}.", CompType, CompName));
+        ShowSevereError(state, format("CheckWaterCoilIsOnAirLoop: = {} = {}.", HVAC::coilTypeNames[(int)coilType], CompName));
         ShowContinueError(state,
                           "The water coil or coil system is neither on primary air branch nor on outdoor air system hence does not require "
                           "'Controller:WaterCoil' object.");
@@ -7454,11 +7427,13 @@ bool CheckWaterCoilOnPrimaryAirLoopBranch(EnergyPlusData &state, SimAirServingZo
 
     if (state.dataHVACGlobal->NumPrimaryAirSys > 0) {
         for (int AirSysNum = 1; AirSysNum <= state.dataHVACGlobal->NumPrimaryAirSys; ++AirSysNum) {
-            auto const &primaryAirSystems = state.dataAirSystemsData->PrimaryAirSystems(AirSysNum);
-            for (int BranchNum = 1; BranchNum <= primaryAirSystems.NumBranches; ++BranchNum) {
-                for (int CompNum = 1; CompNum <= primaryAirSystems.Branch(BranchNum).TotalComponents; ++CompNum) {
-                    if ((CompTypeNum == primaryAirSystems.Branch(BranchNum).Comp(CompNum).CompType_Num) &&
-                        Util::SameString(CompName, primaryAirSystems.Branch(BranchNum).Comp(CompNum).Name)) {
+            auto const &airSys = state.dataAirSystemsData->PrimaryAirSystems(AirSysNum);
+            for (int BranchNum = 1; BranchNum <= airSys.NumBranches; ++BranchNum) {
+                auto const &branch = airSys.Branch(BranchNum);
+                for (int CompNum = 1; CompNum <= branch.TotalComponents; ++CompNum) {
+                    auto const &comp = branch.Comp(CompNum);
+                    if ((CompTypeNum == comp.compType) &&
+                        Util::SameString(CompName, comp.Name)) {
                         return true;
                     }
                 }
@@ -7505,15 +7480,12 @@ bool CheckWaterCoilSystemOnAirLoopOrOASystem(EnergyPlusData &state, SimAirServin
     // and that has water controller is on primary air loop branch or outdoor air system. Searches for water coilsystem
     // type and name that match components list in primary air loop or outside air systems.
 
-    // USE STATEMENTS:
-    using HVACHXAssistedCoolingCoil::GetHXAssistedCoolingCoilInput;
-
     // Return value
     bool CheckWaterCoilSystemIsOnAirLoopOASystem(false);
 
     if (state.dataHVACAssistedCC->GetCoilsInputFlag) {
         // Get the HXAssistedCoolingCoil input
-        GetHXAssistedCoolingCoilInput(state);
+        HXAssistCoil::GetHXAssistedCoolingCoilInput(state);
         state.dataHVACAssistedCC->GetCoilsInputFlag = false;
     }
 
@@ -7524,10 +7496,10 @@ bool CheckWaterCoilSystemOnAirLoopOrOASystem(EnergyPlusData &state, SimAirServin
     if (state.dataHVACAssistedCC->TotalNumHXAssistedCoils > 0) {
         // check if the water coil is placed on 'CoilSystem:Cooling:Water:HeatExchangerAssisted' object
         for (int HXASSCoilNum = 1; HXASSCoilNum <= state.dataHVACAssistedCC->TotalNumHXAssistedCoils; ++HXASSCoilNum) {
-            std::string CompType = state.dataHVACAssistedCC->HXAssistedCoil(HXASSCoilNum).CoolingCoilType;
+            std::string_view CompType = HVAC::coilTypeNames[(int)state.dataHVACAssistedCC->HXAssistedCoils(HXASSCoilNum).coolCoilType];
             if ((Util::SameString(CompType, "Coil:Cooling:Water") || Util::SameString(CompType, "Coil:Cooling:Water:DetailedGeometry")) &&
-                Util::SameString(CompName, state.dataHVACAssistedCC->HXAssistedCoil(HXASSCoilNum).CoolingCoilName)) {
-                CoilSystemName = state.dataHVACAssistedCC->HXAssistedCoil(HXASSCoilNum).Name;
+                Util::SameString(CompName, state.dataHVACAssistedCC->HXAssistedCoils(HXASSCoilNum).CoolCoilName)) {
+                CoilSystemName = state.dataHVACAssistedCC->HXAssistedCoils(HXASSCoilNum).Name;
                 CoilSystemTypeNum = SimAirServingZones::CompType::WaterCoil_CoolingHXAsst;
                 WaterCoilIsOnWaterCoilSystem = true;
                 break;
diff --git a/src/EnergyPlus/SimAirServingZones.hh b/src/EnergyPlus/SimAirServingZones.hh
index f7ba78cb58a..5b2553c5791 100644
--- a/src/EnergyPlus/SimAirServingZones.hh
+++ b/src/EnergyPlus/SimAirServingZones.hh
@@ -74,7 +74,7 @@ namespace SimAirServingZones {
     enum class CompType
     {
         Invalid = -1,
-        OAMixer_Num,
+        OAMixer,
         Fan_Simple_CV,
         Fan_Simple_VAV,
         WaterCoil_Cooling,
@@ -107,6 +107,8 @@ namespace SimAirServingZones {
         Num
     };
 
+    extern const std::array<std::string_view, (int)CompType::Num> compTypeNamesUC;
+  
     void ManageAirLoops(EnergyPlusData &state,
                         bool FirstHVACIteration, // TRUE if first full HVAC iteration in an HVAC timestep
                         bool &SimAir,            // TRUE means air loops must be (re)simulated
@@ -151,7 +153,7 @@ namespace SimAirServingZones {
 
     void SimAirLoopComponent(EnergyPlusData &state,
                              std::string const &CompName, // the component Name
-                             CompType CompType_Num,       // numeric equivalent for component type
+                             CompType compType,       // numeric equivalent for component type
                              bool FirstHVACIteration,     // TRUE if first full HVAC iteration in an HVAC timestep
                              int AirLoopNum,              // Primary air loop number
                              int &CompIndex,              // numeric pointer for CompType/CompName -- passed back from other routines
@@ -197,7 +199,7 @@ namespace SimAirServingZones {
 
     void CheckWaterCoilIsOnAirLoop(EnergyPlusData &state,
                                    SimAirServingZones::CompType CompTypeNum,
-                                   std::string const &CompType,
+                                   HVAC::CoilType coilType,
                                    std::string const &CompName,
                                    bool &WaterCoilOnAirLoop);
 
diff --git a/src/EnergyPlus/SimulationManager.cc b/src/EnergyPlus/SimulationManager.cc
index f79093090dc..d6134dc4b8b 100644
--- a/src/EnergyPlus/SimulationManager.cc
+++ b/src/EnergyPlus/SimulationManager.cc
@@ -220,7 +220,6 @@ namespace SimulationManager {
         OutputProcessor::SetupTimePointers(state, OutputProcessor::TimeStepType::System, state.dataHVACGlobal->TimeStepSys);
 
         createFacilityElectricPowerServiceObject(state);
-        createCoilSelectionReportObj(state);
         // read object information early in simulation
         isInputObjectUsed(state);
 
diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc
index 487e7ab3f2e..62edb2e4761 100644
--- a/src/EnergyPlus/SingleDuct.cc
+++ b/src/EnergyPlus/SingleDuct.cc
@@ -220,13 +220,6 @@ void GetSysInput(EnergyPlusData &state)
 
     // Using/Aliasing
     using NodeInputManager::GetOnlySingleNode;
-    using SteamCoils::GetCoilAirOutletNode;
-    using SteamCoils::GetCoilSteamInletNode;
-    using SteamCoils::GetSteamCoilIndex;
-    using WaterCoils::GetCoilOutletNode;
-    using WaterCoils::GetCoilWaterInletNode;
-    auto &GetHeatingCoilCapacity(HeatingCoils::GetCoilCapacity);
-    auto &GetHeatingCoilOutletNode(HeatingCoils::GetCoilOutletNode);
     using namespace DataHeatBalance;
 
     // SUBROUTINE PARAMETER DEFINITIONS:
@@ -354,211 +347,242 @@ void GetSysInput(EnergyPlusData &state)
                                                                  cNumericFields);
 
         ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-
+          
         state.dataSingleDuct->SysNumGSI = state.dataSingleDuct->SysIndexGSI;
+        auto &sdAirTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
 
-        auto &airTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
-        airTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+        sdAirTerm.SysNum = state.dataSingleDuct->SysNumGSI;
         GlobalNames::VerifyUniqueInterObjectName(
             state, state.dataSingleDuct->SysUniqueNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
-        airTerm.SysName = Alphas(1);
-        airTerm.sysType = CurrentModuleObject;
-        airTerm.SysType_Num = SysType::SingleDuctVAVReheat;
-
-        airTerm.ReheatComp = Alphas(7);
-        if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Fuel")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Gas;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Electric")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Electric;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Water")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SimpleHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Steam")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SteamAirHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-        } else if (!airTerm.ReheatComp.empty()) {
-            ShowSevereError(state, format("Illegal {} = {}.", cAlphaFields(8), airTerm.ReheatComp));
-            ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+
+        sdAirTerm.SysName = Alphas(1);
+        sdAirTerm.sysType = CurrentModuleObject;
+        sdAirTerm.SysType_Num = SysType::SingleDuctVAVReheat;
+
+        sdAirTerm.reheatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(7)));
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) { 
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+        } else {
+            ShowSevereInvalidKey(state, eoh, cAlphaFields(7), Alphas(7));
             ErrorsFound = true;
         }
 
-        airTerm.ReheatName = Alphas(8);
-        if (airTerm.ReheatComp_Num == HeatingCoilType::Gas || airTerm.ReheatComp_Num == HeatingCoilType::Electric) {
-            HeatingCoils::GetCoilIndex(state, airTerm.ReheatName, airTerm.ReheatComp_Index, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        sdAirTerm.ReheatCoilName = Alphas(8);
+
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel || sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+            sdAirTerm.ReheatCoilNum = HeatingCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
                 ErrorsFound = true;
             }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SimpleHeating) {
-            airTerm.ReheatComp_Index = WaterCoils::GetWaterCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilNum = WaterCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
                 ErrorsFound = true;
             }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.ReheatComp_Index = SteamCoils::GetSteamCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilNum = SteamCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
                 ErrorsFound = true;
             }
         }
 
         if (lAlphaBlanks(2)) {
-            airTerm.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((airTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+            sdAirTerm.availSched = Sched::GetScheduleAlwaysOn(state);
+        } else if ((sdAirTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
             ErrorsFound = true;
         }
+        
         // For node connections, this object is both a parent and a non-parent, because the
         // VAV damper is not called out as a separate component, its nodes must be connected
         // as ObjectIsNotParent.  But for the reheat coil, the nodes are connected as ObjectIsParent
-        airTerm.OutletNodeNum = GetOnlySingleNode(state,
-                                                  Alphas(3),
-                                                  ErrorsFound,
-                                                  DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVReheat,
-                                                  Alphas(1),
-                                                  DataLoopNode::NodeFluidType::Air,
-                                                  DataLoopNode::ConnectionType::Outlet,
-                                                  NodeInputManager::CompFluidStream::Primary,
-                                                  ObjectIsNotParent,
-                                                  cAlphaFields(3));
-        airTerm.InletNodeNum = GetOnlySingleNode(state,
-                                                 Alphas(4),
-                                                 ErrorsFound,
-                                                 DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVReheat,
-                                                 Alphas(1),
-                                                 DataLoopNode::NodeFluidType::Air,
-                                                 DataLoopNode::ConnectionType::Inlet,
-                                                 NodeInputManager::CompFluidStream::Primary,
-                                                 ObjectIsNotParent,
-                                                 cAlphaFields(4));
-        airTerm.MaxAirVolFlowRate = Numbers(1);
+        sdAirTerm.OutletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(3),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(3));
+        sdAirTerm.InletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(4),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Inlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(4));
+        sdAirTerm.MaxAirVolFlowRate = Numbers(1);
 
         if (Util::SameString(Alphas(5), "Constant")) {
-            airTerm.ZoneMinAirFracMethod = MinFlowFraction::Constant;
+            sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::Constant;
         } else if (Util::SameString(Alphas(5), "FixedFlowRate")) {
-            airTerm.ZoneMinAirFracMethod = MinFlowFraction::Fixed;
+            sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::Fixed;
         } else if (Util::SameString(Alphas(5), "Scheduled")) {
-            airTerm.ZoneMinAirFracMethod = MinFlowFraction::Scheduled;
+            sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::Scheduled;
         } else {
             ShowSevereError(state, format("{} = {} not found.", cAlphaFields(5), Alphas(5)));
-            ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+            ShowContinueError(state,
+                              format("Occurs in {} = {}",
+                                     sdAirTerm.sysType,
+                                     sdAirTerm.SysName));
             ErrorsFound = true;
         }
 
-        airTerm.ZoneMinAirFracDes = Numbers(2);
+        sdAirTerm.ZoneMinAirFracDes = Numbers(2);
         if (lNumericBlanks(2)) {
-            airTerm.ConstantMinAirFracSetByUser = false;
-            airTerm.DesignMinAirFrac = 0.0;
+            sdAirTerm.ConstantMinAirFracSetByUser = false;
+            sdAirTerm.DesignMinAirFrac = 0.0;
         } else {
-            airTerm.ConstantMinAirFracSetByUser = true;
-            airTerm.DesignMinAirFrac = Numbers(2);
-            if (airTerm.ZoneMinAirFracMethod == MinFlowFraction::Fixed) {
+            sdAirTerm.ConstantMinAirFracSetByUser = true;
+            sdAirTerm.DesignMinAirFrac = Numbers(2);
+            if (sdAirTerm.ZoneMinAirFracMethod == MinFlowFraction::Fixed) {
                 ShowWarningError(state, format("Since {} = {}, input for {} will be ignored.", cAlphaFields(5), Alphas(5), cNumericFields(2)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                airTerm.ZoneMinAirFracDes = 0.0;
+                ShowContinueError(state,
+                                  format("Occurs in {} = {}",
+                                         sdAirTerm.sysType,
+                                         sdAirTerm.SysName));
+                sdAirTerm.ZoneMinAirFracDes = 0.0;
             }
         }
 
-        airTerm.ZoneFixedMinAir = Numbers(3);
+        sdAirTerm.ZoneFixedMinAir = Numbers(3);
         if (lNumericBlanks(3)) {
-            airTerm.FixedMinAirSetByUser = false;
-            airTerm.DesignMinAirFrac = 0.0;
+            sdAirTerm.FixedMinAirSetByUser = false;
+            sdAirTerm.DesignMinAirFrac = 0.0;
         } else {
-            airTerm.FixedMinAirSetByUser = true;
-            airTerm.DesignMinAirFrac = Numbers(3);
-            if (airTerm.ZoneMinAirFracMethod == MinFlowFraction::Constant) {
+            sdAirTerm.FixedMinAirSetByUser = true;
+            sdAirTerm.DesignMinAirFrac = Numbers(3);
+            if (sdAirTerm.ZoneMinAirFracMethod == MinFlowFraction::Constant) {
                 ShowWarningError(state, format("Since {} = {}, input for {} will be ignored.", cAlphaFields(5), Alphas(5), cNumericFields(3)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                airTerm.ZoneFixedMinAir = 0.0;
+                ShowContinueError(state,
+                                  format("Occurs in {} = {}",
+                                         sdAirTerm.sysType,
+                                         sdAirTerm.SysName));
+                sdAirTerm.ZoneFixedMinAir = 0.0;
             }
         }
 
-        if (airTerm.ZoneMinAirFracMethod != MinFlowFraction::Scheduled) {
+        if (sdAirTerm.ZoneMinAirFracMethod != MinFlowFraction::Scheduled) {
         } else if (lAlphaBlanks(6)) {
             ShowSevereEmptyField(state, eoh, cAlphaFields(6));
             ErrorsFound = true;
-        } else if ((airTerm.zoneMinAirFracSched = Sched::GetSchedule(state, Alphas(6))) == nullptr) {
+        } else if ((sdAirTerm.zoneMinAirFracSched = Sched::GetSchedule(state, Alphas(6))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
             ErrorsFound = true;
-        } else if (!airTerm.zoneMinAirFracSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
+        } else if (!sdAirTerm.zoneMinAirFracSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
             Sched::ShowSevereBadMinMax(state, eoh, cAlphaFields(6), Alphas(6), Clusive::In, 0.0, Clusive::In, 1.0);
             ErrorsFound = true;
         }
 
         // The reheat coil control node is necessary for hot water and steam reheat, but not necessary for
         // electric or gas reheat.
-        if (airTerm.ReheatComp_Num != HeatingCoilType::Gas && airTerm.ReheatComp_Num != HeatingCoilType::Electric) {
-            if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilSteamInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                }
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel &&
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+            sdAirTerm.ReheatCoilNum = HeatingCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
+            }
+
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilNum = SteamCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
             } else {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilWaterInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                }
+                sdAirTerm.ReheatControlNode = SteamCoils::GetCoilSteamInletNode(state, sdAirTerm.ReheatCoilNum);
+            }
+
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilNum = WaterCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
+            } else { 
+                sdAirTerm.ReheatControlNode = WaterCoils::GetCoilWaterInletNode(state, sdAirTerm.ReheatCoilNum);
             }
         }
-        airTerm.ReheatAirOutletNode = GetOnlySingleNode(state,
-                                                        Alphas(9),
-                                                        ErrorsFound,
-                                                        DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVReheat,
-                                                        Alphas(1),
-                                                        DataLoopNode::NodeFluidType::Air,
-                                                        DataLoopNode::ConnectionType::Outlet,
-                                                        NodeInputManager::CompFluidStream::Primary,
-                                                        ObjectIsParent,
-                                                        cAlphaFields(9));
-        if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.MaxReheatSteamVolFlow = Numbers(4);
-            airTerm.MinReheatSteamVolFlow = Numbers(5);
-        } else {
-            airTerm.MaxReheatWaterVolFlow = Numbers(4);
-            airTerm.MinReheatWaterVolFlow = Numbers(5);
+        
+        sdAirTerm.ReheatAirOutletNode =
+            GetOnlySingleNode(state,
+                              Alphas(9),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsParent,
+                              cAlphaFields(9));
+
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.MaxReheatSteamVolFlow = Numbers(4);
+            sdAirTerm.MinReheatSteamVolFlow = Numbers(5);
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.MaxReheatWaterVolFlow = Numbers(4);
+            sdAirTerm.MinReheatWaterVolFlow = Numbers(5);
         }
-        airTerm.ControllerOffset = Numbers(6);
+        sdAirTerm.ControllerOffset = Numbers(6);
         // Set default convergence tolerance
-        if (airTerm.ControllerOffset <= 0.0) {
-            airTerm.ControllerOffset = 0.001;
+        if (sdAirTerm.ControllerOffset <= 0.0) {
+            sdAirTerm.ControllerOffset = 0.001;
         }
+        
         if (Util::SameString(Alphas(10), "Reverse")) {
-            airTerm.DamperHeatingAction = Action::Reverse;
+            sdAirTerm.DamperHeatingAction = Action::Reverse;
         } else if (Util::SameString(Alphas(10), "Normal")) {
-            airTerm.DamperHeatingAction = Action::Normal;
+            sdAirTerm.DamperHeatingAction = Action::Normal;
         } else if (Util::SameString(Alphas(10), "ReverseWithLimits")) {
-            airTerm.DamperHeatingAction = Action::ReverseWithLimits;
+            sdAirTerm.DamperHeatingAction = Action::ReverseWithLimits;
         } else {
             ShowSevereError(state, format("{} = {} not found.", cAlphaFields(10), Alphas(10)));
-            ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+            ShowContinueError(state,
+                              format("Occurs in {} = {}",
+                                     sdAirTerm.sysType,
+                                     sdAirTerm.SysName));
             ErrorsFound = true;
         }
 
         // Register component set data
         TestCompSet(state,
-                    airTerm.sysType,
-                    airTerm.SysName,
-                    state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                    state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode),
+                    sdAirTerm.sysType,
+                    sdAirTerm.SysName,
+                    state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                    state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode),
                     "Air Nodes");
 
         for (ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-            if (airTerm.ReheatAirOutletNode == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = airTerm.InletNodeNum;
-                airTerm.ADUNum = ADUNum;
+            if (sdAirTerm.ReheatAirOutletNode == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = sdAirTerm.InletNodeNum;
+                sdAirTerm.ADUNum = ADUNum;
                 break;
             }
         }
         // one assumes if there isn't one assigned, it's an error?
-        if (airTerm.ADUNum == 0) {
+        if (sdAirTerm.ADUNum == 0) {
             ShowSevereError(state,
-                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, airTerm.sysType, airTerm.SysName));
-            ShowContinueError(state, format("...should have outlet node = {}", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
+                            format("{}No matching Air Distribution Unit, for System = [{},{}].",
+                                   RoutineName,
+                                   sdAirTerm.sysType,
+                                   sdAirTerm.SysName));
+            ShowContinueError(
+                state,
+                format("...should have outlet node = {}",
+                       state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode)));
             ErrorsFound = true;
         } else {
 
@@ -566,102 +590,122 @@ void GetSysInput(EnergyPlusData &state)
             for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                 if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                 for (SupAirIn = 1; SupAirIn <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++SupAirIn) {
-                    if (airTerm.ReheatAirOutletNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
+                    if (sdAirTerm.ReheatAirOutletNode ==
+                        state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
                         if (state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode > 0) {
                             ShowSevereError(state, "Error in connecting a terminal unit to a zone");
-                            ShowContinueError(
-                                state, format("{} already connects to another zone", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
-                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
+                            ShowContinueError(state,
+                                              format("{} already connects to another zone",
+                                                     state.dataLoopNodes->NodeID(
+                                                         sdAirTerm.ReheatAirOutletNode)));
+                            ShowContinueError(state,
+                                              format("Occurs for terminal unit {} = {}",
+                                                     sdAirTerm.sysType,
+                                                     sdAirTerm.SysName));
                             ShowContinueError(state, "Check terminal unit node names for errors");
                             ErrorsFound = true;
                         } else {
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = airTerm.InletNodeNum;
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = airTerm.ReheatAirOutletNode;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).TermUnitSizingNum =
-                                state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).ZoneEqNum = CtrlZone;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode =
+                                sdAirTerm.InletNodeNum;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode =
+                                sdAirTerm.ReheatAirOutletNode;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .TermUnitSizingNum = state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .ZoneEqNum = CtrlZone;
                         }
 
-                        airTerm.CtrlZoneNum = CtrlZone;
-                        airTerm.CtrlZoneInNodeIndex = SupAirIn;
-                        airTerm.ZoneFloorArea = state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
-                                                state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
+                        sdAirTerm.CtrlZoneNum = CtrlZone;
+                        sdAirTerm.CtrlZoneInNodeIndex = SupAirIn;
+                        sdAirTerm.ZoneFloorArea =
+                            state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
+                            state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
                     }
                 }
             }
         }
+
         if (Numbers(7) == Constant::AutoCalculate) {
-            airTerm.MaxAirVolFlowRateDuringReheat = Numbers(7);
+            sdAirTerm.MaxAirVolFlowRateDuringReheat = Numbers(7);
         } else {
-            airTerm.MaxAirVolFlowRateDuringReheat = Numbers(7) * airTerm.ZoneFloorArea;
+            sdAirTerm.MaxAirVolFlowRateDuringReheat = Numbers(7) * sdAirTerm.ZoneFloorArea;
         }
 
-        airTerm.MaxAirVolFractionDuringReheat = Numbers(8);
+        sdAirTerm.MaxAirVolFractionDuringReheat = Numbers(8);
 
-        if (airTerm.DamperHeatingAction != Action::ReverseWithLimits) {
-            if (airTerm.MaxAirVolFlowRateDuringReheat > 0.0) {
+        if (sdAirTerm.DamperHeatingAction != Action::ReverseWithLimits) {
+            if (sdAirTerm.MaxAirVolFlowRateDuringReheat > 0.0) {
                 ShowWarningError(state, format("Since {} = {}, input for {} will be ignored.", cAlphaFields(10), Alphas(10), cNumericFields(7)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+                ShowContinueError(state,
+                                  format("Occurs in {} = {}",
+                                         sdAirTerm.sysType,
+                                         sdAirTerm.SysName));
             }
-            if (airTerm.MaxAirVolFractionDuringReheat > 0.0) {
+            if (sdAirTerm.MaxAirVolFractionDuringReheat > 0.0) {
                 ShowWarningError(state, format("Since {} = {}, input for {} will be ignored.", cAlphaFields(10), Alphas(10), cNumericFields(8)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+                ShowContinueError(state,
+                                  format("Occurs in {} = {}",
+                                         sdAirTerm.sysType,
+                                         sdAirTerm.SysName));
             }
         }
 
         // Maximum reheat air temperature, i.e. the maximum supply air temperature leaving the reheat coil
         if (!lNumericBlanks(9)) {
-            airTerm.MaxReheatTemp = Numbers(9);
-            airTerm.MaxReheatTempSetByUser = true;
+            sdAirTerm.MaxReheatTemp = Numbers(9);
+            sdAirTerm.MaxReheatTempSetByUser = true;
         } else {
             // user does not specify maximum supply air temperature
             // sd_airterminal(SysNum)%MaxReheatTemp = 35.0D0 !C
-            airTerm.MaxReheatTempSetByUser = false;
+            sdAirTerm.MaxReheatTempSetByUser = false;
         }
 
         if (!lAlphaBlanks(11)) {
-            airTerm.OARequirementsPtr = Util::FindItemInList(Alphas(11), state.dataSize->OARequirements);
-            if (airTerm.OARequirementsPtr == 0) {
+            sdAirTerm.OARequirementsPtr =
+                Util::FindItemInList(Alphas(11), state.dataSize->OARequirements);
+            if (sdAirTerm.OARequirementsPtr == 0) {
                 ShowSevereError(state, format("{} = {} not found.", cAlphaFields(11), Alphas(11)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+                ShowContinueError(state,
+                                  format("Occurs in {} = {}",
+                                         sdAirTerm.sysType,
+                                         sdAirTerm.SysName));
                 ErrorsFound = true;
             } else {
-                airTerm.NoOAFlowInputFromUser = false;
+                sdAirTerm.NoOAFlowInputFromUser = false;
             }
         }
 
         if (lAlphaBlanks(12)) {
-            airTerm.ZoneTurndownMinAirFrac = 1.0;
-        } else if ((airTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(12))) == nullptr) {
+            sdAirTerm.ZoneTurndownMinAirFrac = 1.0;
+        } else if ((sdAirTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(12))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(12), Alphas(12));
             ErrorsFound = true;
         }
 
-        ValidateComponent(state, Alphas(7), Alphas(8), IsNotOK, airTerm.sysType);
-        if (IsNotOK) {
-            ShowContinueError(state, format("In {} = {}", airTerm.sysType, airTerm.SysName));
-            ErrorsFound = true;
-        }
-
         // Add reheat coil to component sets array
-        SetUpCompSets(state, airTerm.sysType, airTerm.SysName, Alphas(7), Alphas(8), Alphas(3), Alphas(9));
+        SetUpCompSets(state,
+                      sdAirTerm.sysType,
+                      sdAirTerm.SysName,
+                      Alphas(7),
+                      Alphas(8),
+                      Alphas(3),
+                      Alphas(9));
 
         // Setup the Average damper Position output variable
         SetupOutputVariable(state,
                             "Zone Air Terminal VAV Damper Position",
                             Constant::Units::None,
-                            airTerm.DamperPosition,
+                            sdAirTerm.DamperPosition,
                             OutputProcessor::TimeStepType::System,
                             OutputProcessor::StoreType::Average,
-                            airTerm.SysName);
+                            sdAirTerm.SysName);
         SetupOutputVariable(state,
                             "Zone Air Terminal Minimum Air Flow Fraction",
                             Constant::Units::None,
-                            airTerm.ZoneMinAirFracReport,
+                            sdAirTerm.ZoneMinAirFracReport,
                             OutputProcessor::TimeStepType::System,
                             OutputProcessor::StoreType::Average,
-                            airTerm.SysName);
-
+                            sdAirTerm.SysName);
     } // end Number of Sys Loop
 
     for (state.dataSingleDuct->SysIndexGSI = 1; state.dataSingleDuct->SysIndexGSI <= state.dataSingleDuct->NumCBVAVSysGSI;
@@ -683,160 +727,185 @@ void GetSysInput(EnergyPlusData &state)
                                                                  cNumericFields);
 
         ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
+        
         state.dataSingleDuct->SysNumGSI = state.dataSingleDuct->SysIndexGSI + state.dataSingleDuct->NumVAVSysGSI;
-
-        auto &airTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
-        airTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+        auto &sdAirTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
+        sdAirTerm.SysNum = state.dataSingleDuct->SysNumGSI;
         GlobalNames::VerifyUniqueInterObjectName(
             state, state.dataSingleDuct->SysUniqueNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
-        airTerm.SysName = Alphas(1);
-        airTerm.sysType = CurrentModuleObject;
-        airTerm.SysType_Num = SysType::SingleDuctCBVAVReheat;
-        airTerm.ReheatComp = Alphas(5);
-        if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Fuel")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Gas;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Electric")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Electric;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Water")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SimpleHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Steam")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SteamAirHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-        } else if (!airTerm.ReheatComp.empty()) {
-            ShowSevereError(state, format("Illegal {} = {}.", cAlphaFields(5), airTerm.ReheatComp));
-            ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+
+        sdAirTerm.SysName = Alphas(1);
+        sdAirTerm.sysType = CurrentModuleObject;
+        sdAirTerm.SysType_Num = SysType::SingleDuctCBVAVReheat;
+
+        sdAirTerm.reheatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(5)));
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+        } else {
+            ShowSevereInvalidKey(state, eoh, cAlphaFields(5), Alphas(5));
             ErrorsFound = true;
         }
-        airTerm.ReheatName = Alphas(6);
-        if (airTerm.ReheatComp_Num == HeatingCoilType::Gas || airTerm.ReheatComp_Num == HeatingCoilType::Electric) {
-            HeatingCoils::GetCoilIndex(state, airTerm.ReheatName, airTerm.ReheatComp_Index, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        
+        sdAirTerm.ReheatCoilName = Alphas(6);
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel || sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+            sdAirTerm.ReheatCoilNum = HeatingCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
                 ErrorsFound = true;
             }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SimpleHeating) {
-            airTerm.ReheatComp_Index = WaterCoils::GetWaterCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilNum = WaterCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
                 ErrorsFound = true;
             }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.ReheatComp_Index = SteamCoils::GetSteamCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilNum = SteamCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
                 ErrorsFound = true;
             }
         }
 
         if (lAlphaBlanks(2)) {
-            airTerm.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((airTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+            sdAirTerm.availSched = Sched::GetScheduleAlwaysOn(state);
+        } else if ((sdAirTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
             ErrorsFound = true;
         }
         // For node connections, this object is both a parent and a non-parent, because the
         // VAV damper is not called out as a separate component, its nodes must be connected
         // as ObjectIsNotParent.  But for the reheat coil, the nodes are connected as ObjectIsParent
-        airTerm.OutletNodeNum = GetOnlySingleNode(state,
-                                                  Alphas(3),
-                                                  ErrorsFound,
-                                                  DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolReheat,
-                                                  Alphas(1),
-                                                  DataLoopNode::NodeFluidType::Air,
-                                                  DataLoopNode::ConnectionType::Outlet,
-                                                  NodeInputManager::CompFluidStream::Primary,
-                                                  ObjectIsNotParent,
-                                                  cAlphaFields(3));
-        airTerm.InletNodeNum = GetOnlySingleNode(state,
-                                                 Alphas(4),
-                                                 ErrorsFound,
-                                                 DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolReheat,
-                                                 Alphas(1),
-                                                 DataLoopNode::NodeFluidType::Air,
-                                                 DataLoopNode::ConnectionType::Inlet,
-                                                 NodeInputManager::CompFluidStream::Primary,
-                                                 ObjectIsNotParent,
-                                                 cAlphaFields(4));
-        airTerm.MaxAirVolFlowRate = Numbers(1);
-        airTerm.ZoneMinAirFracDes = Numbers(2);
-        if (airTerm.ZoneMinAirFracDes < 0.0) {
-            ShowWarningError(state, format("{} \"{}\"", airTerm.sysType, airTerm.SysName));
+        sdAirTerm.OutletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(3),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(3));
+        sdAirTerm.InletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(4),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Inlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(4));
+        sdAirTerm.MaxAirVolFlowRate = Numbers(1);
+        sdAirTerm.ZoneMinAirFracDes = Numbers(2);
+        if (sdAirTerm.ZoneMinAirFracDes < 0.0) {
+            ShowWarningError(state,
+                             format("{} \"{}\"",
+                                    sdAirTerm.sysType,
+                                    sdAirTerm.SysName));
             ShowContinueError(state,
                               format("{} must be greater than or equal to 0. Resetting to 0 and the simulation continues.", cNumericFields(2)));
-            airTerm.ZoneMinAirFracDes = 0.0;
+            sdAirTerm.ZoneMinAirFracDes = 0.0;
         }
-        if (airTerm.ZoneMinAirFracDes > 1.0) {
-            ShowWarningError(state, format("{} \"{}\"", airTerm.sysType, airTerm.SysName));
+        if (sdAirTerm.ZoneMinAirFracDes > 1.0) {
+            ShowWarningError(state,
+                             format("{} \"{}\"",
+                                    sdAirTerm.sysType,
+                                    sdAirTerm.SysName));
             ShowContinueError(state, format("{} must be less than or equal to 1. Resetting to 1 and the simulation continues.", cNumericFields(2)));
-            airTerm.ZoneMinAirFracDes = 1.0;
+            sdAirTerm.ZoneMinAirFracDes = 1.0;
         }
         // The reheat coil control node is necessary for hot water and steam reheat, but not necessary for
         // electric or gas reheat.
-        if (airTerm.ReheatComp_Num == HeatingCoilType::Gas || airTerm.ReheatComp_Num == HeatingCoilType::Electric) {
-        } else {
-            if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilSteamInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                }
+        sdAirTerm.ReheatCoilName = Alphas(6);
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+            sdAirTerm.ReheatCoilNum = HeatingCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
+            }
+          
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilNum = SteamCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
             } else {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilWaterInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                }
+                sdAirTerm.ReheatControlNode = SteamCoils::GetCoilSteamInletNode(state, sdAirTerm.ReheatCoilNum);
+            }
+
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilNum = WaterCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
+            } else {
+                sdAirTerm.ReheatControlNode = WaterCoils::GetCoilWaterInletNode(state, sdAirTerm.ReheatCoilNum);
             }
-            //  END IF
-        }
-        airTerm.ReheatAirOutletNode = GetOnlySingleNode(state,
-                                                        Alphas(7),
-                                                        ErrorsFound,
-                                                        DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolReheat,
-                                                        Alphas(1),
-                                                        DataLoopNode::NodeFluidType::Air,
-                                                        DataLoopNode::ConnectionType::Outlet,
-                                                        NodeInputManager::CompFluidStream::Primary,
-                                                        ObjectIsParent,
-                                                        cAlphaFields(7));
-        if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.MaxReheatSteamVolFlow = Numbers(3);
-            airTerm.MinReheatSteamVolFlow = Numbers(4);
-        } else {
-            airTerm.MaxReheatWaterVolFlow = Numbers(3);
-            airTerm.MinReheatWaterVolFlow = Numbers(4);
         }
-        airTerm.ControllerOffset = Numbers(5);
+        
+        sdAirTerm.ReheatAirOutletNode =
+            GetOnlySingleNode(state,
+                              Alphas(7),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsParent,
+                              cAlphaFields(7));
+
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.MaxReheatSteamVolFlow = Numbers(3);
+            sdAirTerm.MinReheatSteamVolFlow = Numbers(4);
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.MaxReheatWaterVolFlow = Numbers(3);
+            sdAirTerm.MinReheatWaterVolFlow = Numbers(4);
+        }
+        sdAirTerm.ControllerOffset = Numbers(5);
         // Set default convergence tolerance
-        if (airTerm.ControllerOffset <= 0.0) {
-            airTerm.ControllerOffset = 0.001;
+        if (sdAirTerm.ControllerOffset <= 0.0) {
+            sdAirTerm.ControllerOffset = 0.001;
         }
 
-        airTerm.DamperHeatingAction = Action::Reverse;
+        sdAirTerm.DamperHeatingAction = Action::Reverse;
 
         // Register component set data
         TestCompSet(state,
-                    airTerm.sysType,
-                    airTerm.SysName,
-                    state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                    state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode),
+                    sdAirTerm.sysType,
+                    sdAirTerm.SysName,
+                    state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                    state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode),
                     "Air Nodes");
 
         for (ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-            if (airTerm.ReheatAirOutletNode == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = airTerm.InletNodeNum;
-                airTerm.ADUNum = ADUNum;
+            if (sdAirTerm.ReheatAirOutletNode ==
+                state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = sdAirTerm.InletNodeNum;
+                sdAirTerm.ADUNum = ADUNum;
                 break;
             }
         }
+
         // one assumes if there isn't one assigned, it's an error?
-        if (airTerm.ADUNum == 0) {
+        if (sdAirTerm.ADUNum == 0) {
             ShowSevereError(state,
-                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, airTerm.sysType, airTerm.SysName));
-            ShowContinueError(state, format("...should have outlet node = {}", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
+                            format("{}No matching Air Distribution Unit, for System = [{},{}].",
+                                   RoutineName,
+                                   sdAirTerm.sysType,
+                                   sdAirTerm.SysName));
+            ShowContinueError(
+                state,
+                format("...should have outlet node = {}",
+                       state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode)));
             ErrorsFound = true;
         } else {
 
@@ -844,62 +913,72 @@ void GetSysInput(EnergyPlusData &state)
             for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                 if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                 for (SupAirIn = 1; SupAirIn <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++SupAirIn) {
-                    if (airTerm.ReheatAirOutletNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
+                    if (sdAirTerm.ReheatAirOutletNode ==
+                        state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
                         if (state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode > 0) {
                             ShowSevereError(state, "Error in connecting a terminal unit to a zone");
-                            ShowContinueError(
-                                state, format("{} already connects to another zone", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
-                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
+                            ShowContinueError(state,
+                                              format("{} already connects to another zone",
+                                                     state.dataLoopNodes->NodeID(
+                                                         sdAirTerm.ReheatAirOutletNode)));
+                            ShowContinueError(state,
+                                              format("Occurs for terminal unit {} = {}",
+                                                     sdAirTerm.sysType,
+                                                     sdAirTerm.SysName));
                             ShowContinueError(state, "Check terminal unit node names for errors");
                             ErrorsFound = true;
                         } else {
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = airTerm.InletNodeNum;
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = airTerm.ReheatAirOutletNode;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).TermUnitSizingNum =
-                                state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).ZoneEqNum = CtrlZone;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode =
+                                sdAirTerm.InletNodeNum;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode =
+                                sdAirTerm.ReheatAirOutletNode;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .TermUnitSizingNum = state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .ZoneEqNum = CtrlZone;
                         }
-                        airTerm.CtrlZoneNum = CtrlZone;
-                        airTerm.CtrlZoneInNodeIndex = SupAirIn;
-                        airTerm.ZoneFloorArea = state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
-                                                state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
+                        sdAirTerm.CtrlZoneNum = CtrlZone;
+                        sdAirTerm.CtrlZoneInNodeIndex = SupAirIn;
+                        sdAirTerm.ZoneFloorArea =
+                            state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
+                            state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
                     }
                 }
             }
         }
         if (!lNumericBlanks(6)) {
-            airTerm.MaxReheatTemp = Numbers(6);
-            airTerm.MaxReheatTempSetByUser = true;
+            sdAirTerm.MaxReheatTemp = Numbers(6);
+            sdAirTerm.MaxReheatTempSetByUser = true;
         } else {
             // user does not specify maximum supply air temperature
             // sd_airterminal(SysNum)%MaxReheatTemp = 35.0D0 !C
-            airTerm.MaxReheatTempSetByUser = false;
-        }
-
-        ValidateComponent(state, Alphas(5), Alphas(6), IsNotOK, airTerm.sysType);
-        if (IsNotOK) {
-            ShowContinueError(state, format("In {} = {}", airTerm.sysType, airTerm.SysName));
-            ErrorsFound = true;
+            sdAirTerm.MaxReheatTempSetByUser = false;
         }
 
         if (lAlphaBlanks(8)) {
-            airTerm.ZoneTurndownMinAirFrac = 1.0;
-        } else if ((airTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(8))) == nullptr) {
+            sdAirTerm.ZoneTurndownMinAirFrac = 1.0;
+        } else if ((sdAirTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(8))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
             ErrorsFound = true;
         }
 
         // Add reheat coil to component sets array
-        SetUpCompSets(state, airTerm.sysType, airTerm.SysName, Alphas(5), Alphas(6), Alphas(3), Alphas(7));
+        SetUpCompSets(state,
+                      sdAirTerm.sysType,
+                      sdAirTerm.SysName,
+                      Alphas(5),
+                      Alphas(6),
+                      Alphas(3),
+                      Alphas(7));
 
         // Setup the Average damper Position output variable
         SetupOutputVariable(state,
                             "Zone Air Terminal VAV Damper Position",
                             Constant::Units::None,
-                            airTerm.DamperPosition,
+                            sdAirTerm.DamperPosition,
                             OutputProcessor::TimeStepType::System,
                             OutputProcessor::StoreType::Average,
-                            airTerm.SysName);
+                            sdAirTerm.SysName);
 
     } // end Number of VAVHeatandCool Sys Loop
 
@@ -922,148 +1001,169 @@ void GetSysInput(EnergyPlusData &state)
                                                                  cNumericFields);
 
         ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-
+        
         state.dataSingleDuct->SysNumGSI =
             state.dataSingleDuct->SysIndexGSI + state.dataSingleDuct->NumVAVSysGSI + state.dataSingleDuct->NumCBVAVSysGSI;
-        auto &airTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
 
-        airTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+        auto &sdAirTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
+        
+        sdAirTerm.SysNum = state.dataSingleDuct->SysNumGSI;
         GlobalNames::VerifyUniqueInterObjectName(
             state, state.dataSingleDuct->SysUniqueNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
-        airTerm.SysName = Alphas(1);
-        airTerm.sysType = CurrentModuleObject;
-        airTerm.SysType_Num = SysType::SingleDuctConstVolReheat;
-        airTerm.ReheatComp = Alphas(5);
-        if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Fuel")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Gas;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Electric")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Electric;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Water")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SimpleHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Steam")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SteamAirHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+
+        sdAirTerm.SysName = Alphas(1);
+        sdAirTerm.sysType = CurrentModuleObject;
+        sdAirTerm.SysType_Num = SysType::SingleDuctConstVolReheat;
+
+
+        if (lAlphaBlanks(2)) {
+            sdAirTerm.availSched = Sched::GetScheduleAlwaysOn(state);
+        } else if ((sdAirTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
+            ErrorsFound = true;
+        }
+
+        sdAirTerm.reheatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(5)));
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
         } else {
-            ShowSevereError(state, format("Illegal {} = {}.", cAlphaFields(5), airTerm.ReheatComp));
-            ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+            ShowSevereInvalidKey(state, eoh, cAlphaFields(5), Alphas(5));
             ErrorsFound = true;
         }
-        airTerm.ReheatName = Alphas(6);
-        if (airTerm.ReheatComp_Num == HeatingCoilType::Gas || airTerm.ReheatComp_Num == HeatingCoilType::Electric) {
-            HeatingCoils::GetCoilIndex(state, airTerm.ReheatName, airTerm.ReheatComp_Index, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+
+        sdAirTerm.ReheatCoilName = Alphas(6);
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel || sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+            sdAirTerm.ReheatCoilNum = HeatingCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
                 ErrorsFound = true;
             }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SimpleHeating) {
-            airTerm.ReheatComp_Index = WaterCoils::GetWaterCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilNum = WaterCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
                 ErrorsFound = true;
             }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.ReheatComp_Index = SteamCoils::GetSteamCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilNum = SteamCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
                 ErrorsFound = true;
             }
         }
 
-        if (lAlphaBlanks(2)) {
-            airTerm.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((airTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
-            ErrorsFound = true;
-        }
+        sdAirTerm.OutletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(3),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsParent,
+                              cAlphaFields(3));
+        sdAirTerm.InletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(4),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Inlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsParent,
+                              cAlphaFields(4));
 
-        airTerm.OutletNodeNum = GetOnlySingleNode(state,
-                                                  Alphas(3),
-                                                  ErrorsFound,
-                                                  DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeReheat,
-                                                  Alphas(1),
-                                                  DataLoopNode::NodeFluidType::Air,
-                                                  DataLoopNode::ConnectionType::Outlet,
-                                                  NodeInputManager::CompFluidStream::Primary,
-                                                  ObjectIsParent,
-                                                  cAlphaFields(3));
-        airTerm.InletNodeNum = GetOnlySingleNode(state,
-                                                 Alphas(4),
-                                                 ErrorsFound,
-                                                 DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeReheat,
-                                                 Alphas(1),
-                                                 DataLoopNode::NodeFluidType::Air,
-                                                 DataLoopNode::ConnectionType::Inlet,
-                                                 NodeInputManager::CompFluidStream::Primary,
-                                                 ObjectIsParent,
-                                                 cAlphaFields(4));
         // The reheat coil control node is necessary for hot water reheat, but not necessary for
         // electric or gas reheat.
-        if (airTerm.ReheatComp_Num == HeatingCoilType::Gas || airTerm.ReheatComp_Num == HeatingCoilType::Electric) {
-        } else {
-            if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilSteamInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                }
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+            sdAirTerm.ReheatCoilNum = HeatingCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
+            }
+          
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilNum = SteamCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
             } else {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilWaterInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                }
+                sdAirTerm.ReheatControlNode = SteamCoils::GetCoilSteamInletNode(state, sdAirTerm.ReheatCoilNum);
+            }
+
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilNum = WaterCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
+            } else {
+                sdAirTerm.ReheatControlNode = WaterCoils::GetCoilWaterInletNode(state, sdAirTerm.ReheatCoilNum);
             }
         }
-        airTerm.ReheatAirOutletNode = airTerm.OutletNodeNum;
-        airTerm.MaxAirVolFlowRate = Numbers(1);
-        airTerm.ZoneMinAirFracDes = 0.0;
-        airTerm.ZoneMinAirFracMethod = MinFlowFraction::MinFracNotUsed;
-        airTerm.DamperHeatingAction = Action::HeatingNotUsed;
-        if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.MaxReheatSteamVolFlow = Numbers(2);
-            airTerm.MinReheatSteamVolFlow = Numbers(3);
-        } else {
-            airTerm.MaxReheatWaterVolFlow = Numbers(2);
-            airTerm.MinReheatWaterVolFlow = Numbers(3);
-        }
-        airTerm.ControllerOffset = Numbers(4);
+          
+        sdAirTerm.ReheatAirOutletNode = sdAirTerm.OutletNodeNum;
+        sdAirTerm.MaxAirVolFlowRate = Numbers(1);
+        sdAirTerm.ZoneMinAirFracDes = 0.0;
+        sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::MinFracNotUsed;
+        sdAirTerm.DamperHeatingAction = Action::HeatingNotUsed;
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.MaxReheatSteamVolFlow = Numbers(2);
+            sdAirTerm.MinReheatSteamVolFlow = Numbers(3);
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.MaxReheatWaterVolFlow = Numbers(2);
+            sdAirTerm.MinReheatWaterVolFlow = Numbers(3);
+        }
+        sdAirTerm.ControllerOffset = Numbers(4);
         // Set default convergence tolerance
-        if (airTerm.ControllerOffset <= 0.0) {
-            airTerm.ControllerOffset = 0.001;
+        if (sdAirTerm.ControllerOffset <= 0.0) {
+            sdAirTerm.ControllerOffset = 0.001;
         }
-
+        
         // Maximum reheat air temperature, i.e. the maximum supply air temperature leaving the reheat coil
         if (!lNumericBlanks(5)) {
-            airTerm.MaxReheatTemp = Numbers(5);
-            airTerm.MaxReheatTempSetByUser = true;
+            sdAirTerm.MaxReheatTemp = Numbers(5);
+            sdAirTerm.MaxReheatTempSetByUser = true;
         } else {
             // user does not specify maximum supply air temperature
             // sd_airterminal(SysNum)%MaxReheatTemp = 35.0D0 !C
-            airTerm.MaxReheatTempSetByUser = false;
+            sdAirTerm.MaxReheatTempSetByUser = false;
         }
         // Register component set data
         TestCompSet(state,
-                    airTerm.sysType,
-                    airTerm.SysName,
-                    state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                    state.dataLoopNodes->NodeID(airTerm.OutletNodeNum),
+                    sdAirTerm.sysType,
+                    sdAirTerm.SysName,
+                    state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                    state.dataLoopNodes->NodeID(sdAirTerm.OutletNodeNum),
                     "Air Nodes");
 
         for (ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-            if (airTerm.ReheatAirOutletNode == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = airTerm.InletNodeNum;
-                airTerm.ADUNum = ADUNum;
+            if (sdAirTerm.ReheatAirOutletNode ==
+                state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum =
+                    sdAirTerm.InletNodeNum;
+                sdAirTerm.ADUNum = ADUNum;
                 break;
             }
         }
+
         // one assumes if there isn't one assigned, it's an error?
-        if (airTerm.ADUNum == 0) {
+        if (sdAirTerm.ADUNum == 0) {
             ShowSevereError(state,
-                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, airTerm.sysType, airTerm.SysName));
-            ShowContinueError(state, format("...should have outlet node = {}", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
+                            format("{}No matching Air Distribution Unit, for System = [{},{}].",
+                                   RoutineName,
+                                   sdAirTerm.sysType,
+                                   sdAirTerm.SysName));
+            ShowContinueError(
+                state,
+                format("...should have outlet node = {}",
+                       state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode)));
             ErrorsFound = true;
         } else {
 
@@ -1071,38 +1171,45 @@ void GetSysInput(EnergyPlusData &state)
             for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                 if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                 for (SupAirIn = 1; SupAirIn <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++SupAirIn) {
-                    if (airTerm.OutletNodeNum == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
+                    if (sdAirTerm.OutletNodeNum ==
+                        state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
                         if (state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode > 0) {
                             ShowSevereError(state, "Error in connecting a terminal unit to a zone");
                             ShowContinueError(state,
-                                              format("{} already connects to another zone", state.dataLoopNodes->NodeID(airTerm.OutletNodeNum)));
-                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
+                                              format("{} already connects to another zone",
+                                                     state.dataLoopNodes->NodeID(
+                                                         sdAirTerm.OutletNodeNum)));
+                            ShowContinueError(state,
+                                              format("Occurs for terminal unit {} = {}",
+                                                     sdAirTerm.sysType,
+                                                     sdAirTerm.SysName));
                             ShowContinueError(state, "Check terminal unit node names for errors");
                             ErrorsFound = true;
                         } else {
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = airTerm.InletNodeNum;
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = airTerm.OutletNodeNum;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).TermUnitSizingNum =
-                                state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).ZoneEqNum = CtrlZone;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = sdAirTerm.InletNodeNum;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = sdAirTerm.OutletNodeNum;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum).TermUnitSizingNum =
+                              state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum).ZoneEqNum = CtrlZone;
                         }
-                        airTerm.CtrlZoneNum = CtrlZone;
-                        airTerm.CtrlZoneInNodeIndex = SupAirIn;
-                        airTerm.ZoneFloorArea = state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
-                                                state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
+                        sdAirTerm.CtrlZoneNum = CtrlZone;
+                        sdAirTerm.CtrlZoneInNodeIndex = SupAirIn;
+                        sdAirTerm.ZoneFloorArea =
+                            state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
+                            state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
                     }
                 }
             }
         }
 
-        ValidateComponent(state, Alphas(5), Alphas(6), IsNotOK, airTerm.sysType);
-        if (IsNotOK) {
-            ShowContinueError(state, format("In {} = {}", airTerm.sysType, airTerm.SysName));
-            ErrorsFound = true;
-        }
-
         // Add reheat coil to component sets array
-        SetUpCompSets(state, airTerm.sysType, airTerm.SysName, Alphas(5), Alphas(6), Alphas(4), Alphas(3));
+        SetUpCompSets(state,
+                      sdAirTerm.sysType,
+                      sdAirTerm.SysName,
+                      Alphas(5),
+                      Alphas(6),
+                      Alphas(4),
+                      Alphas(3));
 
         // Setup the Average damper Position output variable
         // BG removed 9-10-2009 during work on CR 7770, constant volume has no damper
@@ -1133,76 +1240,89 @@ void GetSysInput(EnergyPlusData &state)
 
         state.dataSingleDuct->SysNumGSI = state.dataSingleDuct->SysIndexGSI + state.dataSingleDuct->NumVAVSysGSI +
                                           state.dataSingleDuct->NumCBVAVSysGSI + state.dataSingleDuct->NumConstVolSys;
-        auto &airTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
 
-        airTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+        auto &sdAirTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
+        
+        sdAirTerm.SysNum = state.dataSingleDuct->SysNumGSI;
         GlobalNames::VerifyUniqueInterObjectName(
             state, state.dataSingleDuct->SysUniqueNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
-        airTerm.SysName = Alphas(1);
-        airTerm.sysType = CurrentModuleObject;
-        airTerm.SysType_Num = SysType::SingleDuctConstVolNoReheat;
+        sdAirTerm.SysName = Alphas(1);
+        sdAirTerm.sysType = CurrentModuleObject;
+        sdAirTerm.SysType_Num = SysType::SingleDuctConstVolNoReheat;
 
         if (lAlphaBlanks(2)) {
-            airTerm.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((airTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+            sdAirTerm.availSched = Sched::GetScheduleAlwaysOn(state);
+        } else if ((sdAirTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
             ErrorsFound = true;
         }
-
-        airTerm.InletNodeNum = GetOnlySingleNode(state,
-                                                 Alphas(3),
-                                                 ErrorsFound,
-                                                 DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeNoReheat,
-                                                 Alphas(1),
-                                                 DataLoopNode::NodeFluidType::Air,
-                                                 DataLoopNode::ConnectionType::Inlet,
-                                                 NodeInputManager::CompFluidStream::Primary,
-                                                 ObjectIsNotParent,
-                                                 cAlphaFields(3));
-        airTerm.OutletNodeNum = GetOnlySingleNode(state,
-                                                  Alphas(4),
-                                                  ErrorsFound,
-                                                  DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeNoReheat,
-                                                  Alphas(1),
-                                                  DataLoopNode::NodeFluidType::Air,
-                                                  DataLoopNode::ConnectionType::Outlet,
-                                                  NodeInputManager::CompFluidStream::Primary,
-                                                  ObjectIsNotParent,
-                                                  cAlphaFields(4));
-
-        airTerm.MaxAirVolFlowRate = Numbers(1);
-        airTerm.ZoneMinAirFracDes = 0.0;
-        airTerm.ZoneMinAirFracMethod = MinFlowFraction::MinFracNotUsed;
-        airTerm.DamperHeatingAction = Action::HeatingNotUsed;
-
-        airTerm.ReheatControlNode = 0;
-        airTerm.ReheatAirOutletNode = airTerm.OutletNodeNum;
-        airTerm.MaxReheatWaterVolFlow = 0.0;
-        airTerm.MaxReheatSteamVolFlow = 0.0;
-        airTerm.MinReheatWaterVolFlow = 0.0;
-        airTerm.MinReheatSteamVolFlow = 0.0;
-        airTerm.ControllerOffset = 0.000001;
+        
+        sdAirTerm.InletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(3),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeNoReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Inlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(3));
+        sdAirTerm.OutletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(4),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctConstantVolumeNoReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(4));
+
+        sdAirTerm.MaxAirVolFlowRate = Numbers(1);
+        sdAirTerm.ZoneMinAirFracDes = 0.0;
+        sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::MinFracNotUsed;
+        sdAirTerm.DamperHeatingAction = Action::HeatingNotUsed;
+
+        sdAirTerm.ReheatControlNode = 0;
+        sdAirTerm.ReheatAirOutletNode =
+            sdAirTerm.OutletNodeNum;
+        sdAirTerm.MaxReheatWaterVolFlow = 0.0;
+        sdAirTerm.MaxReheatSteamVolFlow = 0.0;
+        sdAirTerm.MinReheatWaterVolFlow = 0.0;
+        sdAirTerm.MinReheatSteamVolFlow = 0.0;
+        sdAirTerm.ControllerOffset = 0.000001;
 
         // Register component set data
         TestCompSet(state,
-                    airTerm.sysType,
-                    airTerm.SysName,
-                    state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                    state.dataLoopNodes->NodeID(airTerm.OutletNodeNum),
+                    sdAirTerm.sysType,
+                    sdAirTerm.SysName,
+                    state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                    state.dataLoopNodes->NodeID(sdAirTerm.OutletNodeNum),
                     "Air Nodes");
 
         for (ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-            if (airTerm.OutletNodeNum == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = airTerm.InletNodeNum;
-                airTerm.ADUNum = ADUNum;
+            if (sdAirTerm.OutletNodeNum ==
+                state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum =
+                    sdAirTerm.InletNodeNum;
+                sdAirTerm.ADUNum = ADUNum;
                 break;
             }
         }
+
         // one assumes if there isn't one assigned, it's an error?
-        if (airTerm.ADUNum == 0) {
+        if (sdAirTerm.ADUNum == 0) {
             ShowSevereError(state,
-                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, airTerm.sysType, airTerm.SysName));
-            ShowContinueError(state, format("...should have outlet node = {}", state.dataLoopNodes->NodeID(airTerm.OutletNodeNum)));
+                            format("{}No matching Air Distribution Unit, for System = [{},{}].",
+                                   RoutineName,
+                                   sdAirTerm.sysType,
+                                   sdAirTerm.SysName));
+            ShowContinueError(
+                state,
+                format("...should have outlet node = {}",
+                       state.dataLoopNodes->NodeID(sdAirTerm.OutletNodeNum)));
             ErrorsFound = true;
         } else {
 
@@ -1210,52 +1330,63 @@ void GetSysInput(EnergyPlusData &state)
             for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                 if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                 for (SupAirIn = 1; SupAirIn <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++SupAirIn) {
-                    if (airTerm.OutletNodeNum == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
+                    if (sdAirTerm.OutletNodeNum ==
+                        state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
                         if (state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode > 0) {
                             ShowSevereError(state, "Error in connecting a terminal unit to a zone");
                             ShowContinueError(state,
-                                              format("{} already connects to another zone", state.dataLoopNodes->NodeID(airTerm.OutletNodeNum)));
-                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
+                                              format("{} already connects to another zone",
+                                                     state.dataLoopNodes->NodeID(
+                                                         sdAirTerm.OutletNodeNum)));
+                            ShowContinueError(state,
+                                              format("Occurs for terminal unit {} = {}",
+                                                     sdAirTerm.sysType,
+                                                     sdAirTerm.SysName));
                             ShowContinueError(state, "Check terminal unit node names for errors");
                             ErrorsFound = true;
                         } else {
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = airTerm.InletNodeNum;
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = airTerm.OutletNodeNum;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).TermUnitSizingNum =
-                                state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).ZoneEqNum = CtrlZone;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode =
+                                sdAirTerm.InletNodeNum;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode =
+                                sdAirTerm.OutletNodeNum;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .TermUnitSizingNum = state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .ZoneEqNum = CtrlZone;
                         }
-                        airTerm.CtrlZoneNum = CtrlZone;
-                        airTerm.CtrlZoneInNodeIndex = SupAirIn;
-                        airTerm.ZoneFloorArea = state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
-                                                state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
+                        sdAirTerm.CtrlZoneNum = CtrlZone;
+                        sdAirTerm.CtrlZoneInNodeIndex = SupAirIn;
+                        sdAirTerm.ZoneFloorArea =
+                            state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
+                            state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
                     }
                 }
             }
         }
 
         if (lAlphaBlanks(5)) {
-            airTerm.NoOAFlowInputFromUser = true;
+            sdAirTerm.NoOAFlowInputFromUser = true;
         } else {
-            airTerm.OARequirementsPtr = Util::FindItemInList(Alphas(5), state.dataSize->OARequirements);
-            if (airTerm.OARequirementsPtr == 0) {
+            sdAirTerm.OARequirementsPtr =
+                Util::FindItemInList(Alphas(5), state.dataSize->OARequirements);
+            if (sdAirTerm.OARequirementsPtr == 0) {
                 ShowSevereError(state, format("{}{}=\"{}\", invalid data.", RoutineName, CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state, format("..invalid {}=\"{}\".", cAlphaFields(5), Alphas(5)));
                 ErrorsFound = true;
             } else {
-                airTerm.NoOAFlowInputFromUser = false;
+                sdAirTerm.NoOAFlowInputFromUser = false;
             }
         }
 
         if (lAlphaBlanks(6)) {
-            airTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::DCVByCurrentLevel;
+            sdAirTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::DCVByCurrentLevel;
         } else {
             if (Alphas(6) == "CURRENTOCCUPANCY") {
-                airTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::DCVByCurrentLevel;
+                sdAirTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::DCVByCurrentLevel;
             } else if (Alphas(6) == "DESIGNOCCUPANCY") {
-                airTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::ByDesignLevel;
+                sdAirTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::ByDesignLevel;
             } else {
-                airTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::DCVByCurrentLevel;
+                sdAirTerm.OAPerPersonMode = DataZoneEquipment::PerPersonVentRateMode::DCVByCurrentLevel;
                 ShowWarningError(state, format("{}{}=\"{}\", invalid data.", RoutineName, CurrentModuleObject, Alphas(1)));
                 ShowContinueError(state,
                                   format("..invalid {}=\"{}\". The default input of CurrentOccupancy is assigned", cAlphaFields(6), Alphas(6)));
@@ -1266,25 +1397,26 @@ void GetSysInput(EnergyPlusData &state)
             // model results related actuators
             SetupEMSActuator(state,
                              "AirTerminal:SingleDuct:ConstantVolume:NoReheat",
-                             airTerm.SysName,
+                             sdAirTerm.SysName,
                              "Mass Flow Rate",
                              "[kg/s]",
-                             airTerm.EMSOverrideAirFlow,
-                             airTerm.EMSMassFlowRateValue);
+                             sdAirTerm.EMSOverrideAirFlow,
+                             sdAirTerm.EMSMassFlowRateValue);
             // model input related internal variables
             SetupEMSInternalVariable(state,
                                      "AirTerminal:SingleDuct:ConstantVolume:NoReheat Maximum Mass Flow Rate",
-                                     airTerm.SysName,
+                                     sdAirTerm.SysName,
                                      "[kg/s]",
-                                     airTerm.AirMassFlowRateMax);
+                                     sdAirTerm.AirMassFlowRateMax);
         }
 
     } // End Number of Sys Loop
 
+    CurrentModuleObject = "AirTerminal:SingleDuct:VAV:NoReheat";
+    
     for (state.dataSingleDuct->SysIndexGSI = 1; state.dataSingleDuct->SysIndexGSI <= state.dataSingleDuct->NumNoRHVAVSysGSI;
          ++state.dataSingleDuct->SysIndexGSI) {
 
-        CurrentModuleObject = "AirTerminal:SingleDuct:VAV:NoReheat";
 
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                  CurrentModuleObject,
@@ -1303,127 +1435,144 @@ void GetSysInput(EnergyPlusData &state)
         state.dataSingleDuct->SysNumGSI = state.dataSingleDuct->SysIndexGSI + state.dataSingleDuct->NumVAVSysGSI +
                                           state.dataSingleDuct->NumCBVAVSysGSI + state.dataSingleDuct->NumConstVolSys +
                                           state.dataSingleDuct->NumCVNoReheatSysGSI;
-        auto &airTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
 
-        airTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+        auto &sdAirTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
+        sdAirTerm.SysNum = state.dataSingleDuct->SysNumGSI;
         GlobalNames::VerifyUniqueInterObjectName(
             state, state.dataSingleDuct->SysUniqueNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
-        airTerm.SysName = Alphas(1);
-        airTerm.sysType = CurrentModuleObject;
-        airTerm.SysType_Num = SysType::SingleDuctVAVNoReheat;
-        airTerm.ReheatComp = "";
-        airTerm.ReheatName = "";
-
+        sdAirTerm.SysName = Alphas(1);
+        sdAirTerm.sysType = CurrentModuleObject;
+        sdAirTerm.SysType_Num = SysType::SingleDuctVAVNoReheat;
+        sdAirTerm.reheatCoilType = HVAC::CoilType::Invalid;
+        sdAirTerm.ReheatCoilName = "";
+        
         if (lAlphaBlanks(2)) {
-            airTerm.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((airTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+            sdAirTerm.availSched = Sched::GetScheduleAlwaysOn(state);
+        } else if ((sdAirTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
             ErrorsFound = true;
         }
 
-        airTerm.OutletNodeNum = GetOnlySingleNode(state,
-                                                  Alphas(3),
-                                                  ErrorsFound,
-                                                  DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVNoReheat,
-                                                  Alphas(1),
-                                                  DataLoopNode::NodeFluidType::Air,
-                                                  DataLoopNode::ConnectionType::Outlet,
-                                                  NodeInputManager::CompFluidStream::Primary,
-                                                  ObjectIsNotParent,
-                                                  cAlphaFields(3));
-        airTerm.InletNodeNum = GetOnlySingleNode(state,
-                                                 Alphas(4),
-                                                 ErrorsFound,
-                                                 DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVNoReheat,
-                                                 Alphas(1),
-                                                 DataLoopNode::NodeFluidType::Air,
-                                                 DataLoopNode::ConnectionType::Inlet,
-                                                 NodeInputManager::CompFluidStream::Primary,
-                                                 ObjectIsNotParent,
-                                                 cAlphaFields(4));
-        airTerm.MaxAirVolFlowRate = Numbers(1);
+        sdAirTerm.OutletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(3),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVNoReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(3));
+        sdAirTerm.InletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(4),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVNoReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Inlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(4));
+        sdAirTerm.MaxAirVolFlowRate = Numbers(1);
 
         if (Util::SameString(Alphas(5), "Constant")) {
-            airTerm.ZoneMinAirFracMethod = MinFlowFraction::Constant;
+            sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::Constant;
         } else if (Util::SameString(Alphas(5), "FixedFlowRate")) {
-            airTerm.ZoneMinAirFracMethod = MinFlowFraction::Fixed;
+            sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::Fixed;
         } else if (Util::SameString(Alphas(5), "Scheduled")) {
-            airTerm.ZoneMinAirFracMethod = MinFlowFraction::Scheduled;
+            sdAirTerm.ZoneMinAirFracMethod = MinFlowFraction::Scheduled;
         } else {
             ShowSevereError(state, format("{} = {} not found.", cAlphaFields(5), Alphas(5)));
-            ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+            ShowContinueError(state,
+                              format("Occurs in {} = {}",
+                                     sdAirTerm.sysType,
+                                     sdAirTerm.SysName));
             ErrorsFound = true;
         }
 
-        airTerm.ZoneMinAirFracDes = Numbers(2);
+        sdAirTerm.ZoneMinAirFracDes = Numbers(2);
         if (lNumericBlanks(2)) {
-            airTerm.ConstantMinAirFracSetByUser = false;
-            airTerm.ZoneMinAirFracDes = 0.0;
+            sdAirTerm.ConstantMinAirFracSetByUser = false;
+            sdAirTerm.ZoneMinAirFracDes = 0.0;
         } else {
-            airTerm.ConstantMinAirFracSetByUser = true;
-            airTerm.ZoneMinAirFracDes = Numbers(2);
-            if (airTerm.ZoneMinAirFracMethod == MinFlowFraction::Fixed) {
+            sdAirTerm.ConstantMinAirFracSetByUser = true;
+            sdAirTerm.ZoneMinAirFracDes = Numbers(2);
+            if (sdAirTerm.ZoneMinAirFracMethod == MinFlowFraction::Fixed) {
                 ShowWarningError(state, format("Since {} = {}, input for {} will be ignored.", cAlphaFields(5), Alphas(5), cNumericFields(2)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                airTerm.ZoneMinAirFracDes = 0.0;
+                ShowContinueError(state,
+                                  format("Occurs in {} = {}",
+                                         sdAirTerm.sysType,
+                                         sdAirTerm.SysName));
+                sdAirTerm.ZoneMinAirFracDes = 0.0;
             }
         }
 
-        airTerm.ZoneFixedMinAir = Numbers(3);
+        sdAirTerm.ZoneFixedMinAir = Numbers(3);
         if (lNumericBlanks(3)) {
-            airTerm.FixedMinAirSetByUser = false;
-            airTerm.DesignFixedMinAir = 0.0;
+            sdAirTerm.FixedMinAirSetByUser = false;
+            sdAirTerm.DesignFixedMinAir = 0.0;
         } else {
-            airTerm.FixedMinAirSetByUser = true;
-            airTerm.DesignFixedMinAir = Numbers(3);
-            if (airTerm.ZoneMinAirFracMethod == MinFlowFraction::Constant) {
+            sdAirTerm.FixedMinAirSetByUser = true;
+            sdAirTerm.DesignFixedMinAir = Numbers(3);
+            if (sdAirTerm.ZoneMinAirFracMethod == MinFlowFraction::Constant) {
                 ShowWarningError(state, format("Since {} = {}, input for {} will be ignored.", cAlphaFields(5), Alphas(5), cNumericFields(3)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                airTerm.ZoneFixedMinAir = 0.0;
+                ShowContinueError(state,
+                                  format("Occurs in {} = {}",
+                                         sdAirTerm.sysType,
+                                         sdAirTerm.SysName));
+                sdAirTerm.ZoneFixedMinAir = 0.0;
             }
         }
 
-        if (airTerm.ZoneMinAirFracMethod != MinFlowFraction::Scheduled) {
+        if (sdAirTerm.ZoneMinAirFracMethod != MinFlowFraction::Scheduled) {
         } else if (lAlphaBlanks(6)) {
             ShowSevereEmptyField(state, eoh, cAlphaFields(6));
             ErrorsFound = true;
-        } else if ((airTerm.zoneMinAirFracSched = Sched::GetSchedule(state, Alphas(6))) == nullptr) {
+        } else if ((sdAirTerm.zoneMinAirFracSched = Sched::GetSchedule(state, Alphas(6))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(6), Alphas(6));
             ErrorsFound = true;
-        } else if (!airTerm.zoneMinAirFracSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
+        } else if (!sdAirTerm.zoneMinAirFracSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
             Sched::ShowSevereBadMinMax(state, eoh, cAlphaFields(6), Alphas(6), Clusive::In, 0.0, Clusive::In, 1.0);
             ErrorsFound = true;
         }
 
-        airTerm.ReheatControlNode = 0;
-        airTerm.ReheatAirOutletNode = airTerm.OutletNodeNum;
-        airTerm.MaxReheatWaterVolFlow = 0.0;
-        airTerm.MaxReheatSteamVolFlow = 0.0;
-        airTerm.MinReheatWaterVolFlow = 0.0;
-        airTerm.MinReheatSteamVolFlow = 0.0;
-        airTerm.ControllerOffset = 0.000001;
-        airTerm.DamperHeatingAction = Action::HeatingNotUsed;
+        sdAirTerm.ReheatControlNode = 0;
+        sdAirTerm.ReheatAirOutletNode = sdAirTerm.OutletNodeNum;
+        sdAirTerm.MaxReheatWaterVolFlow = 0.0;
+        sdAirTerm.MaxReheatSteamVolFlow = 0.0;
+        sdAirTerm.MinReheatWaterVolFlow = 0.0;
+        sdAirTerm.MinReheatSteamVolFlow = 0.0;
+        sdAirTerm.ControllerOffset = 0.000001;
+        sdAirTerm.DamperHeatingAction = Action::HeatingNotUsed;
 
         // Register component set data
         TestCompSet(state,
-                    airTerm.sysType,
-                    airTerm.SysName,
-                    state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                    state.dataLoopNodes->NodeID(airTerm.OutletNodeNum),
+                    sdAirTerm.sysType,
+                    sdAirTerm.SysName,
+                    state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                    state.dataLoopNodes->NodeID(sdAirTerm.OutletNodeNum),
                     "Air Nodes");
 
         for (ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-            if (airTerm.OutletNodeNum == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = airTerm.InletNodeNum;
-                airTerm.ADUNum = ADUNum;
+            if (sdAirTerm.OutletNodeNum == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = sdAirTerm.InletNodeNum;
+                sdAirTerm.ADUNum = ADUNum;
                 break;
             }
         }
         // one assumes if there isn't one assigned, it's an error?
-        if (airTerm.ADUNum == 0) {
+        if (sdAirTerm.ADUNum == 0) {
             ShowSevereError(state,
-                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, airTerm.sysType, airTerm.SysName));
-            ShowContinueError(state, format("...should have outlet node = {}", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
+                            format("{}No matching Air Distribution Unit, for System = [{},{}].",
+                                   RoutineName,
+                                   sdAirTerm.sysType,
+                                   sdAirTerm.SysName));
+            ShowContinueError(
+                state,
+                format("...should have outlet node = {}",
+                       state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode)));
             ErrorsFound = true;
         } else {
 
@@ -1431,44 +1580,54 @@ void GetSysInput(EnergyPlusData &state)
             for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                 if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                 for (SupAirIn = 1; SupAirIn <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++SupAirIn) {
-                    if (airTerm.ReheatAirOutletNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
+                    if (sdAirTerm.ReheatAirOutletNode ==
+                        state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
                         if (state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode > 0) {
                             ShowSevereError(state, "Error in connecting a terminal unit to a zone");
-                            ShowContinueError(
-                                state, format("{} already connects to another zone", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
-                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
+                            ShowContinueError(state,
+                                              format("{} already connects to another zone",
+                                                     state.dataLoopNodes->NodeID(
+                                                         sdAirTerm.ReheatAirOutletNode)));
+                            ShowContinueError(state,
+                                              format("Occurs for terminal unit {} = {}",
+                                                     sdAirTerm.sysType,
+                                                     sdAirTerm.SysName));
                             ShowContinueError(state, "Check terminal unit node names for errors");
                             ErrorsFound = true;
                         } else {
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = airTerm.InletNodeNum;
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = airTerm.ReheatAirOutletNode;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).TermUnitSizingNum =
-                                state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).ZoneEqNum = CtrlZone;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode =
+                                sdAirTerm.InletNodeNum;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode =
+                                sdAirTerm.ReheatAirOutletNode;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .TermUnitSizingNum = state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum)
+                                .ZoneEqNum = CtrlZone;
                         }
 
-                        airTerm.CtrlZoneNum = CtrlZone;
-                        airTerm.CtrlZoneInNodeIndex = SupAirIn;
-                        airTerm.ZoneFloorArea = state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
-                                                state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
+                        sdAirTerm.CtrlZoneNum = CtrlZone;
+                        sdAirTerm.CtrlZoneInNodeIndex = SupAirIn;
+                        sdAirTerm.ZoneFloorArea =
+                            state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
+                            state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
                     }
                 }
             }
         }
         if (!lAlphaBlanks(7)) {
-            airTerm.OARequirementsPtr = Util::FindItemInList(Alphas(7), state.dataSize->OARequirements);
-            if (airTerm.OARequirementsPtr == 0) {
+            sdAirTerm.OARequirementsPtr = Util::FindItemInList(Alphas(7), state.dataSize->OARequirements);
+            if (sdAirTerm.OARequirementsPtr == 0) {
                 ShowSevereError(state, format("{} = {} not found.", cAlphaFields(7), Alphas(7)));
-                ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+                ShowContinueError(state, format("Occurs in {} = {}", sdAirTerm.sysType, sdAirTerm.SysName));
                 ErrorsFound = true;
             } else {
-                airTerm.NoOAFlowInputFromUser = false;
+                sdAirTerm.NoOAFlowInputFromUser = false;
             }
         }
 
         if (lAlphaBlanks(8)) {
-            airTerm.ZoneTurndownMinAirFrac = 1.0;
-        } else if ((airTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(8))) == nullptr) {
+            sdAirTerm.ZoneTurndownMinAirFrac = 1.0;
+        } else if ((sdAirTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(8))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
             ErrorsFound = true;
         }
@@ -1477,18 +1636,17 @@ void GetSysInput(EnergyPlusData &state)
         SetupOutputVariable(state,
                             "Zone Air Terminal VAV Damper Position",
                             Constant::Units::None,
-                            airTerm.DamperPosition,
+                            sdAirTerm.DamperPosition,
                             OutputProcessor::TimeStepType::System,
                             OutputProcessor::StoreType::Average,
-                            airTerm.SysName);
+                            sdAirTerm.SysName);
         SetupOutputVariable(state,
                             "Zone Air Terminal Minimum Air Flow Fraction",
                             Constant::Units::None,
-                            airTerm.ZoneMinAirFracReport,
+                            sdAirTerm.ZoneMinAirFracReport,
                             OutputProcessor::TimeStepType::System,
                             OutputProcessor::StoreType::Average,
-                            airTerm.SysName);
-
+                            sdAirTerm.SysName);
     } // end Number of Sys Loop
 
     for (state.dataSingleDuct->SysIndexGSI = 1; state.dataSingleDuct->SysIndexGSI <= state.dataSingleDuct->NumNoRHCBVAVSysGSI;
@@ -1513,87 +1671,104 @@ void GetSysInput(EnergyPlusData &state)
         state.dataSingleDuct->SysNumGSI = state.dataSingleDuct->SysIndexGSI + state.dataSingleDuct->NumVAVSysGSI +
                                           state.dataSingleDuct->NumCBVAVSysGSI + state.dataSingleDuct->NumConstVolSys +
                                           state.dataSingleDuct->NumCVNoReheatSysGSI + state.dataSingleDuct->NumNoRHVAVSysGSI;
-        auto &airTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
 
-        airTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+        auto &sdAirTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
+        sdAirTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+        
         GlobalNames::VerifyUniqueInterObjectName(
             state, state.dataSingleDuct->SysUniqueNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
-        airTerm.SysName = Alphas(1);
-        airTerm.sysType = CurrentModuleObject;
-        airTerm.SysType_Num = SysType::SingleDuctCBVAVNoReheat;
-        airTerm.ReheatComp = "";
-        airTerm.ReheatName = "";
-
+        sdAirTerm.SysName = Alphas(1);
+        sdAirTerm.sysType = CurrentModuleObject;
+        sdAirTerm.SysType_Num = SysType::SingleDuctCBVAVNoReheat;
+        sdAirTerm.reheatCoilType = HVAC::CoilType::Invalid;
+        sdAirTerm.ReheatCoilName = "";
+        
         if (lAlphaBlanks(2)) {
-            airTerm.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((airTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+            sdAirTerm.availSched = Sched::GetScheduleAlwaysOn(state);
+        } else if ((sdAirTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
             ErrorsFound = true;
         }
 
-        airTerm.OutletNodeNum = GetOnlySingleNode(state,
-                                                  Alphas(3),
-                                                  ErrorsFound,
-                                                  DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolNoReheat,
-                                                  Alphas(1),
-                                                  DataLoopNode::NodeFluidType::Air,
-                                                  DataLoopNode::ConnectionType::Outlet,
-                                                  NodeInputManager::CompFluidStream::Primary,
-                                                  ObjectIsNotParent,
-                                                  cAlphaFields(3));
-        airTerm.InletNodeNum = GetOnlySingleNode(state,
-                                                 Alphas(4),
-                                                 ErrorsFound,
-                                                 DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolNoReheat,
-                                                 Alphas(1),
-                                                 DataLoopNode::NodeFluidType::Air,
-                                                 DataLoopNode::ConnectionType::Inlet,
-                                                 NodeInputManager::CompFluidStream::Primary,
-                                                 ObjectIsNotParent,
-                                                 cAlphaFields(4));
-        airTerm.MaxAirVolFlowRate = Numbers(1);
-        airTerm.ZoneMinAirFracDes = Numbers(2);
-        if (airTerm.ZoneMinAirFracDes < 0.0) {
-            ShowWarningError(state, format("{} = \"{}", airTerm.sysType, airTerm.SysName));
+        sdAirTerm.OutletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(3),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolNoReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Outlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(3));
+        sdAirTerm.InletNodeNum =
+            GetOnlySingleNode(state,
+                              Alphas(4),
+                              ErrorsFound,
+                              DataLoopNode::ConnectionObjectType::AirTerminalSingleDuctVAVHeatAndCoolNoReheat,
+                              Alphas(1),
+                              DataLoopNode::NodeFluidType::Air,
+                              DataLoopNode::ConnectionType::Inlet,
+                              NodeInputManager::CompFluidStream::Primary,
+                              ObjectIsNotParent,
+                              cAlphaFields(4));
+        sdAirTerm.MaxAirVolFlowRate = Numbers(1);
+        sdAirTerm.ZoneMinAirFracDes = Numbers(2);
+        if (sdAirTerm.ZoneMinAirFracDes < 0.0) {
+            ShowWarningError(state,
+                             format("{} = \"{}",
+                                    sdAirTerm.sysType,
+                                    sdAirTerm.SysName));
             ShowContinueError(state,
                               format("{} must be greater than or equal to 0. Resetting to 0 and the simulation continues.", cNumericFields(2)));
-            airTerm.ZoneMinAirFracDes = 0.0;
+            sdAirTerm.ZoneMinAirFracDes = 0.0;
         }
-        if (airTerm.ZoneMinAirFracDes > 1.0) {
-            ShowWarningError(state, format("{} = \"{}", airTerm.sysType, airTerm.SysName));
+        if (sdAirTerm.ZoneMinAirFracDes > 1.0) {
+            ShowWarningError(state,
+                             format("{} = \"{}",
+                                    sdAirTerm.sysType,
+                                    sdAirTerm.SysName));
             ShowContinueError(state, format("{} must be less than or equal to 1. Resetting to 1 and the simulation continues.", cNumericFields(2)));
-            airTerm.ZoneMinAirFracDes = 1.0;
+            sdAirTerm.ZoneMinAirFracDes = 1.0;
         }
 
-        airTerm.ReheatControlNode = 0;
-        airTerm.ReheatAirOutletNode = airTerm.OutletNodeNum;
-        airTerm.MaxReheatWaterVolFlow = 0.0;
-        airTerm.MaxReheatSteamVolFlow = 0.0;
-        airTerm.MinReheatWaterVolFlow = 0.0;
-        airTerm.MinReheatSteamVolFlow = 0.0;
-        airTerm.ControllerOffset = 0.000001;
-        airTerm.DamperHeatingAction = Action::HeatingNotUsed;
+        sdAirTerm.ReheatControlNode = 0;
+        sdAirTerm.ReheatAirOutletNode =
+            sdAirTerm.OutletNodeNum;
+        sdAirTerm.MaxReheatWaterVolFlow = 0.0;
+        sdAirTerm.MaxReheatSteamVolFlow = 0.0;
+        sdAirTerm.MinReheatWaterVolFlow = 0.0;
+        sdAirTerm.MinReheatSteamVolFlow = 0.0;
+        sdAirTerm.ControllerOffset = 0.000001;
+        sdAirTerm.DamperHeatingAction = Action::HeatingNotUsed;
 
         // Register component set data
         TestCompSet(state,
-                    airTerm.sysType,
-                    airTerm.SysName,
-                    state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                    state.dataLoopNodes->NodeID(airTerm.OutletNodeNum),
+                    sdAirTerm.sysType,
+                    sdAirTerm.SysName,
+                    state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                    state.dataLoopNodes->NodeID(sdAirTerm.OutletNodeNum),
                     "Air Nodes");
 
         for (ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-            if (airTerm.OutletNodeNum == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = airTerm.InletNodeNum;
-                airTerm.ADUNum = ADUNum;
+            if (sdAirTerm.OutletNodeNum == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = sdAirTerm.InletNodeNum;
+                sdAirTerm.ADUNum = ADUNum;
                 break;
             }
         }
         // one assumes if there isn't one assigned, it's an error?
-        if (airTerm.ADUNum == 0) {
+
+        if (sdAirTerm.ADUNum == 0) {
             ShowSevereError(state,
-                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, airTerm.sysType, airTerm.SysName));
-            ShowContinueError(state, format("...should have outlet node = {}", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
+                            format("{}No matching Air Distribution Unit, for System = [{},{}].",
+                                   RoutineName,
+                                   sdAirTerm.sysType,
+                                   sdAirTerm.SysName));
+            ShowContinueError(
+                state,
+                format("...should have outlet node = {}",
+                       state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode)));
             ErrorsFound = true;
         } else {
 
@@ -1601,33 +1776,40 @@ void GetSysInput(EnergyPlusData &state)
             for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                 if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                 for (SupAirIn = 1; SupAirIn <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++SupAirIn) {
-                    if (airTerm.ReheatAirOutletNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
+                    if (sdAirTerm.ReheatAirOutletNode ==
+                        state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
                         if (state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode > 0) {
                             ShowSevereError(state, "Error in connecting a terminal unit to a zone");
-                            ShowContinueError(
-                                state, format("{} already connects to another zone", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
-                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
+                            ShowContinueError(state,
+                                              format("{} already connects to another zone",
+                                                     state.dataLoopNodes->NodeID(
+                                                         sdAirTerm.ReheatAirOutletNode)));
+                            ShowContinueError(state,
+                                              format("Occurs for terminal unit {} = {}",
+                                                     sdAirTerm.sysType,
+                                                     sdAirTerm.SysName));
                             ShowContinueError(state, "Check terminal unit node names for errors");
                             ErrorsFound = true;
                         } else {
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = airTerm.InletNodeNum;
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = airTerm.ReheatAirOutletNode;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).TermUnitSizingNum =
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = sdAirTerm.InletNodeNum;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = sdAirTerm.ReheatAirOutletNode;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum).TermUnitSizingNum =
                                 state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).ZoneEqNum = CtrlZone;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum).ZoneEqNum = CtrlZone;
                         }
-                        airTerm.CtrlZoneNum = CtrlZone;
-                        airTerm.CtrlZoneInNodeIndex = SupAirIn;
-                        airTerm.ZoneFloorArea = state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
-                                                state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
+                        sdAirTerm.CtrlZoneNum = CtrlZone;
+                        sdAirTerm.CtrlZoneInNodeIndex = SupAirIn;
+                        sdAirTerm.ZoneFloorArea =
+                            state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
+                            state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
                     }
                 }
             }
         }
 
         if (lAlphaBlanks(5)) {
-            airTerm.ZoneTurndownMinAirFrac = 1.0;
-        } else if ((airTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(5))) == nullptr) {
+            sdAirTerm.ZoneTurndownMinAirFrac = 1.0;
+        } else if ((sdAirTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(5))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(5), Alphas(5));
             ErrorsFound = true;
         }
@@ -1636,11 +1818,10 @@ void GetSysInput(EnergyPlusData &state)
         SetupOutputVariable(state,
                             "Zone Air Terminal VAV Damper Position",
                             Constant::Units::None,
-                            airTerm.DamperPosition,
+                            sdAirTerm.DamperPosition,
                             OutputProcessor::TimeStepType::System,
                             OutputProcessor::StoreType::Average,
-                            airTerm.SysName);
-
+                            sdAirTerm.SysName);
     } // end Number of VAVHeatandCool:NoReheat Sys Loop
 
     // read in the SINGLE DUCT:VAV:REHEAT:VS FAN data
@@ -1663,210 +1844,164 @@ void GetSysInput(EnergyPlusData &state)
                                                                  cNumericFields);
 
         ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
-
+        
         state.dataSingleDuct->SysNumGSI = state.dataSingleDuct->SysIndexGSI + state.dataSingleDuct->NumVAVSysGSI +
                                           state.dataSingleDuct->NumCBVAVSysGSI + state.dataSingleDuct->NumConstVolSys +
                                           state.dataSingleDuct->NumCVNoReheatSysGSI + state.dataSingleDuct->NumNoRHVAVSysGSI +
                                           state.dataSingleDuct->NumNoRHCBVAVSysGSI;
-        auto &airTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
-        airTerm.SysNum = state.dataSingleDuct->SysNumGSI;
+
+        auto &sdAirTerm = state.dataSingleDuct->sd_airterminal(state.dataSingleDuct->SysNumGSI);
+        sdAirTerm.SysNum = state.dataSingleDuct->SysNumGSI;
         GlobalNames::VerifyUniqueInterObjectName(
             state, state.dataSingleDuct->SysUniqueNames, Alphas(1), CurrentModuleObject, cAlphaFields(1), ErrorsFound);
-        airTerm.SysName = Alphas(1);
-        airTerm.sysType = CurrentModuleObject;
-        airTerm.SysType_Num = SysType::SingleDuctVAVReheatVSFan;
-        airTerm.ReheatComp = Alphas(7);
-        airTerm.ReheatName = Alphas(8);
-        IsNotOK = false;
-        if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Fuel")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Gas;
-            airTerm.ReheatAirOutletNode = GetHeatingCoilOutletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-            airTerm.ReheatCoilMaxCapacity = GetHeatingCoilCapacity(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-            if (IsNotOK) ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Electric")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::Electric;
-            airTerm.ReheatAirOutletNode = GetHeatingCoilOutletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-            airTerm.ReheatCoilMaxCapacity = GetHeatingCoilCapacity(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-            if (IsNotOK) ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Water")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SimpleHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-        } else if (Util::SameString(airTerm.ReheatComp, "Coil:Heating:Steam")) {
-            airTerm.ReheatComp_Num = HeatingCoilType::SteamAirHeating;
-            airTerm.ReheatComp_PlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-        } else if (!airTerm.ReheatComp.empty()) {
-            ShowSevereError(state, format("Illegal {} = {}.", cAlphaFields(7), airTerm.ReheatComp));
-            ShowContinueError(state, format("Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-            ErrorsFound = true;
-        }
 
-        if (airTerm.ReheatComp_Num == HeatingCoilType::Gas || airTerm.ReheatComp_Num == HeatingCoilType::Electric) {
-            HeatingCoils::GetCoilIndex(state, airTerm.ReheatName, airTerm.ReheatComp_Index, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
-                ErrorsFound = true;
-            }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SimpleHeating) {
-            airTerm.ReheatComp_Index = WaterCoils::GetWaterCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
-                ErrorsFound = true;
-            }
-        } else if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.ReheatComp_Index = SteamCoils::GetSteamCoilIndex(state, airTerm.ReheatComp, airTerm.ReheatName, ErrorsFound);
-            if (airTerm.ReheatComp_Index == 0) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), Alphas(8));
+        sdAirTerm.SysName = Alphas(1);
+        sdAirTerm.sysType = CurrentModuleObject;
+        sdAirTerm.SysType_Num = SysType::SingleDuctVAVReheatVSFan;
+
+        sdAirTerm.reheatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(7)));
+        sdAirTerm.ReheatCoilName = Alphas(8);
+
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+            sdAirTerm.ReheatCoilNum = HeatingCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), sdAirTerm.ReheatCoilName);
                 ErrorsFound = true;
+            } else {
+                sdAirTerm.ReheatAirOutletNode = HeatingCoils::GetCoilAirOutletNode(state, sdAirTerm.ReheatCoilNum);
+                sdAirTerm.ReheatCoilMaxCapacity = HeatingCoils::GetCoilCapacity(state, sdAirTerm.ReheatCoilNum);
             }
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+        } else { 
+            ShowSevereInvalidKey(state, eoh, cAlphaFields(7), Alphas(7));
+            ErrorsFound = true;
         }
+        
+        sdAirTerm.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(5)));
 
-        airTerm.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(5)));
-
-        if (airTerm.fanType != HVAC::FanType::VAV && airTerm.fanType != HVAC::FanType::SystemModel) {
+        if (sdAirTerm.fanType != HVAC::FanType::VAV && sdAirTerm.fanType != HVAC::FanType::SystemModel) {
             ShowSevereInvalidKey(state, eoh, cAlphaFields(5), Alphas(5), "Support fan types are Fan:VAV and Fan:SystemModel");
 
             ErrorsFound = true;
         }
 
-        airTerm.FanName = Alphas(6);
+        sdAirTerm.FanName = Alphas(6);
 
-        airTerm.Fan_Index = Fans::GetFanIndex(state, airTerm.FanName);
-        if (airTerm.Fan_Index == 0) {
-            ShowSevereItemNotFound(state, eoh, cAlphaFields(6), airTerm.FanName);
+        sdAirTerm.Fan_Index = Fans::GetFanIndex(state, sdAirTerm.FanName);
+        if (sdAirTerm.Fan_Index == 0) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFields(6), sdAirTerm.FanName);
             ErrorsFound = true;
         }
-        airTerm.OutletNodeNum = state.dataFans->fans(airTerm.Fan_Index)->outletNodeNum;
-        airTerm.InletNodeNum = state.dataFans->fans(airTerm.Fan_Index)->inletNodeNum;
+        sdAirTerm.OutletNodeNum = state.dataFans->fans(sdAirTerm.Fan_Index)->outletNodeNum;
+        sdAirTerm.InletNodeNum = state.dataFans->fans(sdAirTerm.Fan_Index)->inletNodeNum;
 
-        if (airTerm.fanType == HVAC::FanType::SystemModel) {
-            dynamic_cast<Fans::FanSystem *>(state.dataFans->fans(airTerm.Fan_Index))->isSecondaryDriver = true;
+        if (sdAirTerm.fanType == HVAC::FanType::SystemModel) {
+            dynamic_cast<Fans::FanSystem *>(state.dataFans->fans(sdAirTerm.Fan_Index))->isSecondaryDriver = true;
         }
 
         if (lAlphaBlanks(2)) {
-            airTerm.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((airTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+            sdAirTerm.availSched = Sched::GetScheduleAlwaysOn(state);
+        } else if ((sdAirTerm.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
             ErrorsFound = true;
         }
 
-        AirTermSysInletNodeName = state.dataLoopNodes->NodeID(airTerm.InletNodeNum);
+        AirTermSysInletNodeName = state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum);
         if (!Util::SameString(Alphas(3), AirTermSysInletNodeName)) {
             ShowWarningError(state,
-                             format("{}Invalid air terminal object air inlet node name in {} = {}", RoutineName, airTerm.sysType, airTerm.SysName));
+                             format("{}Invalid air terminal object air inlet node name in {} = {}",
+                                    RoutineName,
+                                    sdAirTerm.sysType,
+                                    sdAirTerm.SysName));
             ShowContinueError(state, format(" Specified air inlet node name is = {}.", Alphas(3)));
             ShowContinueError(state, format(" Expected air inlet node name is = {}.", AirTermSysInletNodeName));
             // ErrorsFound = true;
         }
 
-        airTerm.MaxAirVolFlowRate = Numbers(1);
-        airTerm.MaxHeatAirVolFlowRate = Numbers(2);
-        airTerm.ZoneMinAirFracDes = Numbers(3);
+        sdAirTerm.MaxAirVolFlowRate = Numbers(1);
+        sdAirTerm.MaxHeatAirVolFlowRate = Numbers(2);
+        sdAirTerm.ZoneMinAirFracDes = Numbers(3);
         // The reheat coil control node is necessary for hot water reheat, but not necessary for
         // electric or gas reheat.
-        if (airTerm.ReheatComp_Num == HeatingCoilType::Gas || airTerm.ReheatComp_Num == HeatingCoilType::Electric) {
-            //          IF(.NOT. lAlphaBlanks(6)) THEN
-            //            CALL ShowWarningError(state, 'In '//TRIM(sd_airterminal(SysNum)%SysType)//' = ' // TRIM(sd_airterminal(SysNum)%SysName) &
-            //                                 // ' the '//TRIM(cAlphaFields(6))//' is not needed and will be ignored.')
-            //            CALL ShowContinueError(state, '  It is used for hot water reheat coils only.')
-            //          END IF
-        } else {
-            //          IF(lAlphaBlanks(6)) THEN
-            //            CALL ShowSevereError(state, 'In '//TRIM(sd_airterminal(SysNum)%SysType)//' = ' // TRIM(sd_airterminal(SysNum)%SysName) &
-            //                                 // ' the '//TRIM(cAlphaFields(6))//' is undefined')
-            //            ErrorsFound=.TRUE.
-            //          END IF
-            if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilSteamInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                } else {
-                    //  A4,     \field Unit supply air outlet node
-                    //          \note same as heating coil air outlet node
-                    //          \note same as zone inlet node
-                    //          \type alpha
-                    IsNotOK = false;
-                    airTerm.ReheatAirOutletNode = GetCoilAirOutletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                        ErrorsFound = true;
-                    }
-                }
-                //               GetOnlySingleNode(state, Alphas(6),ErrorsFound,sd_airterminal(SysNum)%SysType,Alphas(1), &
-                //                                DataLoopNode::NodeFluidType::Steam,DataLoopNode::NodeConnectionType::Actuator,1,ObjectIsParent)
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingElectric) {
+
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.ReheatCoilNum = SteamCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
             } else {
-                IsNotOK = false;
-                airTerm.ReheatControlNode = GetCoilWaterInletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                    ErrorsFound = true;
-                } else {
-                    //  A4,     \field Unit supply air outlet node
-                    //          \note same as heating coil air outlet node
-                    //          \note same as zone inlet node
-                    //          \type alpha
-                    IsNotOK = false;
-                    airTerm.ReheatAirOutletNode = GetCoilOutletNode(state, airTerm.ReheatComp, airTerm.ReheatName, IsNotOK);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
-                        ErrorsFound = true;
-                    }
-                }
-                //               GetOnlySingleNode(state, Alphas(6),ErrorsFound,sd_airterminal(SysNum)%SysType,Alphas(1), &
-                //                                DataLoopNode::NodeFluidType::Water,DataLoopNode::NodeConnectionType::Actuator,1,ObjectIsParent)
+                sdAirTerm.ReheatControlNode = SteamCoils::GetCoilSteamInletNode(state, sdAirTerm.ReheatCoilNum);
+                sdAirTerm.ReheatAirOutletNode = SteamCoils::GetCoilAirOutletNode(state, sdAirTerm.ReheatCoilNum);
+            }
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) { 
+            sdAirTerm.ReheatCoilNum = WaterCoils::GetCoilIndex(state, sdAirTerm.ReheatCoilName);
+            if (sdAirTerm.ReheatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(8), sdAirTerm.ReheatCoilName);
+                ErrorsFound = true;
+            } else {
+                sdAirTerm.ReheatControlNode = WaterCoils::GetCoilWaterInletNode(state, sdAirTerm.ReheatCoilNum);
+                sdAirTerm.ReheatAirOutletNode = WaterCoils::GetCoilAirOutletNode(state, sdAirTerm.ReheatCoilNum);
             }
         }
-        //  A4,     \field Unit supply air outlet node
-        //          \note same as heating coil air outlet node
-        //          \note same as zone inlet node
-        //          \type alpha
-        //        sd_airterminal(SysNum)%ReheatAirOutletNode  = &
-        //               GetOnlySingleNode(state, Alphas(4),ErrorsFound,sd_airterminal(SysNum)%SysType,Alphas(1), &
-        //                            DataLoopNode::NodeFluidType::Air,DataLoopNode::NodeConnectionType::Outlet,1,ObjectIsParent)
-        AirTermSysOutletNodeName = state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode);
+
+        AirTermSysOutletNodeName = state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode);
         if (!Util::SameString(Alphas(4), AirTermSysOutletNodeName)) {
             ShowWarningError(state,
-                             format("{}Invalid air terminal object air outlet node name in {} = {}", RoutineName, airTerm.sysType, airTerm.SysName));
+                             format("{}Invalid air terminal object air outlet node name in {} = {}",
+                                    RoutineName,
+                                    sdAirTerm.sysType,
+                                    sdAirTerm.SysName));
             ShowContinueError(state, format(" Specified air outlet node name is = {}.", Alphas(4)));
             ShowContinueError(state, format(" Expected air outlet node name is = {}.", AirTermSysOutletNodeName));
             // ErrorsFound = true;
         }
 
-        if (airTerm.ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
-            airTerm.MaxReheatSteamVolFlow = Numbers(4);
-            airTerm.MinReheatSteamVolFlow = Numbers(5);
-        } else {
-            airTerm.MaxReheatWaterVolFlow = Numbers(4);
-            airTerm.MinReheatWaterVolFlow = Numbers(5);
+        if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingSteam) {
+            sdAirTerm.MaxReheatSteamVolFlow = Numbers(4);
+            sdAirTerm.MinReheatSteamVolFlow = Numbers(5);
+        } else if (sdAirTerm.reheatCoilType == HVAC::CoilType::HeatingWater) {
+            sdAirTerm.MaxReheatWaterVolFlow = Numbers(4);
+            sdAirTerm.MinReheatWaterVolFlow = Numbers(5);
         }
-        airTerm.ControllerOffset = Numbers(6);
+        
+        sdAirTerm.ControllerOffset = Numbers(6);
         // Set default convergence tolerance
-        if (airTerm.ControllerOffset <= 0.0) {
-            airTerm.ControllerOffset = 0.001;
+        if (sdAirTerm.ControllerOffset <= 0.0) {
+            sdAirTerm.ControllerOffset = 0.001;
         }
-        airTerm.DamperHeatingAction = Action::HeatingNotUsed;
+        sdAirTerm.DamperHeatingAction = Action::HeatingNotUsed;
 
         // Register component set data
         TestCompSet(state,
-                    airTerm.sysType,
-                    airTerm.SysName,
-                    state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                    state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode),
+                    sdAirTerm.sysType,
+                    sdAirTerm.SysName,
+                    state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                    state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode),
                     "Air Nodes");
 
         for (ADUNum = 1; ADUNum <= (int)state.dataDefineEquipment->AirDistUnit.size(); ++ADUNum) {
-            if (airTerm.ReheatAirOutletNode == state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
-                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum = airTerm.InletNodeNum;
-                airTerm.ADUNum = ADUNum;
+            if (sdAirTerm.ReheatAirOutletNode ==
+                state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum) {
+                state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum =
+                    sdAirTerm.InletNodeNum;
+                sdAirTerm.ADUNum = ADUNum;
                 break;
             }
         }
         // one assumes if there isn't one assigned, it's an error?
-        if (airTerm.ADUNum == 0) {
+        if (sdAirTerm.ADUNum == 0) {
             ShowSevereError(state,
-                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, airTerm.sysType, airTerm.SysName));
-            ShowContinueError(state, format("...should have outlet node = {}", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
+                            format("{}No matching Air Distribution Unit, for System = [{},{}].", RoutineName, sdAirTerm.sysType, sdAirTerm.SysName));
+            ShowContinueError(
+                state,
+                format("...should have outlet node = {}",
+                       state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode)));
             ErrorsFound = true;
         } else {
 
@@ -1876,67 +2011,69 @@ void GetSysInput(EnergyPlusData &state)
             for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                 if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                 for (SupAirIn = 1; SupAirIn <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++SupAirIn) {
-                    if (airTerm.ReheatAirOutletNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
+                    if (sdAirTerm.ReheatAirOutletNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(SupAirIn)) {
                         IsNotOK = false;
                         if (state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode > 0) {
                             ShowSevereError(state, "Error in connecting a terminal unit to a zone");
-                            ShowContinueError(
-                                state, format("{} already connects to another zone", state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode)));
-                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", airTerm.sysType, airTerm.SysName));
+                            ShowContinueError(state,
+                                              format("{} already connects to another zone",
+                                                     state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode)));
+                            ShowContinueError(state, format("Occurs for terminal unit {} = {}", sdAirTerm.sysType, sdAirTerm.SysName));
                             ShowContinueError(state, "Check terminal unit node names for errors");
                             ErrorsFound = true;
                         } else {
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = airTerm.InletNodeNum;
-                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = airTerm.ReheatAirOutletNode;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).TermUnitSizingNum =
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).InNode = sdAirTerm.InletNodeNum;
+                            state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).OutNode = sdAirTerm.ReheatAirOutletNode;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum).TermUnitSizingNum =
                                 state.dataZoneEquip->ZoneEquipConfig(CtrlZone).AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
-                            state.dataDefineEquipment->AirDistUnit(airTerm.ADUNum).ZoneEqNum = CtrlZone;
+                            state.dataDefineEquipment->AirDistUnit(sdAirTerm.ADUNum).ZoneEqNum = CtrlZone;
                         }
-                        airTerm.CtrlZoneNum = CtrlZone;
-                        airTerm.CtrlZoneInNodeIndex = SupAirIn;
-                        airTerm.ZoneFloorArea = state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
-                                                state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
+                        sdAirTerm.CtrlZoneNum = CtrlZone;
+                        sdAirTerm.CtrlZoneInNodeIndex = SupAirIn;
+                        sdAirTerm.ZoneFloorArea =
+                            state.dataHeatBal->Zone(CtrlZone).FloorArea * state.dataHeatBal->Zone(CtrlZone).Multiplier *
+                            state.dataHeatBal->Zone(CtrlZone).ListMultiplier;
                     }
                 }
             }
         }
         if (IsNotOK) {
             ShowWarningError(state, "Did not Match Supply Air Outlet Node to any Zone Node");
-            ShowContinueError(state, format("..Occurs in {} = {}", airTerm.sysType, airTerm.SysName));
+            ShowContinueError(state, format("..Occurs in {} = {}", sdAirTerm.sysType, sdAirTerm.SysName));
         }
 
         if (lAlphaBlanks(9)) {
-            airTerm.ZoneTurndownMinAirFrac = 1.0;
-        } else if ((airTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(9))) == nullptr) {
+            sdAirTerm.ZoneTurndownMinAirFrac = 1.0;
+        } else if ((sdAirTerm.zoneTurndownMinAirFracSched = Sched::GetSchedule(state, Alphas(9))) == nullptr) {
             ShowSevereItemNotFound(state, eoh, cAlphaFields(9), Alphas(9));
             ErrorsFound = true;
         }
 
         // Add reheat coil to component sets array
         SetUpCompSets(state,
-                      airTerm.sysType,
-                      airTerm.SysName,
+                      sdAirTerm.sysType,
+                      sdAirTerm.SysName,
                       Alphas(7),
                       Alphas(8),
-                      state.dataLoopNodes->NodeID(airTerm.OutletNodeNum),
-                      state.dataLoopNodes->NodeID(airTerm.ReheatAirOutletNode));
+                      state.dataLoopNodes->NodeID(sdAirTerm.OutletNodeNum),
+                      state.dataLoopNodes->NodeID(sdAirTerm.ReheatAirOutletNode));
         // Add fan to component sets array
         SetUpCompSets(state,
-                      airTerm.sysType,
-                      airTerm.SysName,
+                      sdAirTerm.sysType,
+                      sdAirTerm.SysName,
                       Alphas(5),
                       Alphas(6),
-                      state.dataLoopNodes->NodeID(airTerm.InletNodeNum),
-                      state.dataLoopNodes->NodeID(airTerm.OutletNodeNum));
+                      state.dataLoopNodes->NodeID(sdAirTerm.InletNodeNum),
+                      state.dataLoopNodes->NodeID(sdAirTerm.OutletNodeNum));
 
         // Setup the Average damper Position output variable
         SetupOutputVariable(state,
                             "Zone Air Terminal VAV Damper Position",
                             Constant::Units::None,
-                            airTerm.DamperPosition,
+                            sdAirTerm.DamperPosition,
                             OutputProcessor::TimeStepType::System,
                             OutputProcessor::StoreType::Average,
-                            airTerm.SysName);
+                            sdAirTerm.SysName);
     }
 
     // common report variable for all single duct air terminals
@@ -2014,7 +2151,6 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI
     using DataZoneEquipment::CheckZoneEquipmentList;
     using PlantUtilities::InitComponentNodes;
     using PlantUtilities::ScanPlantLoopsForObject;
-    auto &GetHeatingCoilCapacity(HeatingCoils::GetCoilCapacity);
 
     // SUBROUTINE PARAMETER DEFINITIONS:
     static constexpr std::string_view RoutineName("InitSys");
@@ -2032,11 +2168,11 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI
 
     // Do the Begin Simulation initializations
     if (this->PlantLoopScanFlag && allocated(state.dataPlnt->PlantLoop)) {
-        if ((this->ReheatComp_PlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
-            (this->ReheatComp_PlantType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
+        if ((this->ReheatCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
+            (this->ReheatCoilPlantType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
             // setup plant topology indices for plant fed heating coils
             errFlag = false;
-            ScanPlantLoopsForObject(state, this->ReheatName, this->ReheatComp_PlantType, this->HWplantLoc, errFlag, _, _, _, _, _);
+            ScanPlantLoopsForObject(state, this->ReheatCoilName, this->ReheatCoilPlantType, this->HWplantLoc, errFlag, _, _, _, _, _);
 
             if (errFlag) {
                 ShowContinueError(state, format("Reference Unit=\"{}\", type={}", this->SysName, this->sysType));
@@ -2087,11 +2223,9 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI
     }
 
     if (this->GetGasElecHeatCoilCap) {
-        if (this->ReheatComp_Num == HeatingCoilType::Electric || this->ReheatComp_Num == HeatingCoilType::Gas) {
+        if (this->reheatCoilType == HVAC::CoilType::HeatingElectric || this->reheatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel) {
             if (this->ReheatCoilMaxCapacity == AutoSize) {
-                errFlag = false;
-                this->ReheatCoilMaxCapacity = GetHeatingCoilCapacity(state, this->ReheatComp, this->ReheatName, errFlag);
-                if (errFlag) ShowContinueError(state, format("Occurs for terminal unit {} = {}", this->sysType, this->SysName));
+                this->ReheatCoilMaxCapacity = HeatingCoils::GetCoilCapacity(state, this->ReheatCoilNum);
             }
             if (this->ReheatCoilMaxCapacity != AutoSize) {
                 this->GetGasElecHeatCoilCap = false;
@@ -2113,7 +2247,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI
         state.dataLoopNodes->Node(InletNode).MassFlowRateMax = this->MaxAirVolFlowRate * state.dataEnvrn->StdRhoAir;
         this->MassFlowDiff = 1.0e-10 * this->AirMassFlowRateMax;
 
-        if (this->HWplantLoc.loopNum > 0 && this->ReheatComp_Num != HeatingCoilType::SteamAirHeating) { // protect early calls before plant is setup
+        if (this->HWplantLoc.loopNum > 0 && this->reheatCoilType != HVAC::CoilType::HeatingSteam) { // protect early calls before plant is setup
             rho = state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
         } else {
             rho = 1000.0;
@@ -2126,7 +2260,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI
 
         // set the upstream leakage flowrate - remove from here - done in ZoneAirLoopEquipmentManager::SimZoneAirLoopEquipment
 
-        if (this->ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
+        if (this->reheatCoilType == HVAC::CoilType::HeatingSteam) {
             SteamTemp = 100.0;
             SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, SteamTemp, 1.0, RoutineNameFull);
             this->MaxReheatSteamFlow = SteamDensity * this->MaxReheatSteamVolFlow;
@@ -2153,7 +2287,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI
             state.dataLoopNodes->Node(InletNode).MassFlowRateMin = 0.0;
         }
         if ((this->ReheatControlNode > 0) && !this->PlantLoopScanFlag) {
-            if (this->ReheatComp_Num == HeatingCoilType::SteamAirHeating) {
+            if (this->reheatCoilType == HVAC::CoilType::HeatingSteam) {
                 InitComponentNodes(state, this->MinReheatSteamFlow, this->MaxReheatSteamFlow, this->ReheatControlNode, this->ReheatCoilOutletNode);
             } else {
                 InitComponentNodes(state, this->MinReheatWaterFlow, this->MaxReheatWaterFlow, this->ReheatControlNode, this->ReheatCoilOutletNode);
@@ -2332,11 +2466,6 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
     // Using/Aliasing
     using General::SafeDivide;
     using PlantUtilities::MyPlantSizingIndex;
-    using SteamCoils::GetCoilSteamInletNode;
-    using SteamCoils::GetCoilSteamOutletNode;
-    using WaterCoils::GetCoilWaterInletNode;
-    using WaterCoils::GetCoilWaterOutletNode;
-    using WaterCoils::SetCoilDesFlow;
 
     // SUBROUTINE PARAMETER DEFINITIONS:
     static constexpr std::string_view RoutineName("SizeSys");
@@ -2443,9 +2572,12 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
     if (this->MaxHeatAirVolFlowRate == AutoSize) {
         IsAutoSize = true;
     }
+
+    Real64 UserInputMaxHeatAirVolFlowRate = 0.0;
+    
     if (state.dataSize->CurTermUnitSizingNum > 0) {
         if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // simulation should continue
-            state.dataSingleDuct->UserInputMaxHeatAirVolFlowRateSS = this->MaxHeatAirVolFlowRate;
+            UserInputMaxHeatAirVolFlowRate = this->MaxHeatAirVolFlowRate;
             if (this->MaxHeatAirVolFlowRate > 0.0) {
                 BaseSizer::reportSizerOutput(
                     state, this->sysType, this->SysName, "User-Specified Maximum Heating Air Flow Rate [m3/s]", this->MaxHeatAirVolFlowRate);
@@ -2464,13 +2596,13 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
             }
             if (IsAutoSize) {
                 this->MaxHeatAirVolFlowRate = MaxHeatAirVolFlowRateDes;
-                state.dataSingleDuct->UserInputMaxHeatAirVolFlowRateSS = 0.0;
+                UserInputMaxHeatAirVolFlowRate = 0.0;
                 BaseSizer::reportSizerOutput(
                     state, this->sysType, this->SysName, "Design Size Maximum Heating Air Flow Rate [m3/s]", MaxHeatAirVolFlowRateDes);
             } else { // Hard-size with sizing data
                 if (this->MaxHeatAirVolFlowRate > 0.0 && MaxHeatAirVolFlowRateDes > 0.0) {
                     MaxHeatAirVolFlowRateUser = this->MaxHeatAirVolFlowRate;
-                    state.dataSingleDuct->UserInputMaxHeatAirVolFlowRateSS = this->MaxHeatAirVolFlowRate;
+                    UserInputMaxHeatAirVolFlowRate = this->MaxHeatAirVolFlowRate;
                     BaseSizer::reportSizerOutput(state,
                                                  this->sysType,
                                                  this->SysName,
@@ -2939,7 +3071,7 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
             // set air flow rate used to size heating coils, ZoneTurndownMinAirFrac defaults to 1 for those TU types that do not use it
             if (this->SysType_Num == SysType::SingleDuctVAVReheatVSFan) {
                 TermUnitSizing(state.dataSize->CurTermUnitSizingNum).AirVolFlow =
-                    max(state.dataSingleDuct->UserInputMaxHeatAirVolFlowRateSS,
+                    max(UserInputMaxHeatAirVolFlowRate,
                         state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).NonAirSysDesHeatVolFlow,
                         this->MaxAirVolFlowRate * this->ZoneMinAirFracDes * this->ZoneTurndownMinAirFrac);
             } else if (this->SysType_Num == SysType::SingleDuctConstVolReheat || this->SysType_Num == SysType::SingleDuctConstVolNoReheat) {
@@ -3010,9 +3142,9 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
             TermUnitSizing(state.dataSize->CurTermUnitSizingNum).ReheatAirFlowMult = 1.0;
             TermUnitSizing(state.dataSize->CurTermUnitSizingNum).ReheatLoadMult = 1.0;
         }
-        if (this->ReheatComp_Index > 0) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(
-                state, this->ReheatName, this->ReheatComp, TermUnitSizing(state.dataSize->CurTermUnitSizingNum).ReheatLoadMult);
+        if (this->ReheatCoilNum > 0) {
+            ReportCoilSelection::setCoilReheatMultiplier(
+                state, this->ReheatCoilName, this->reheatCoilType, TermUnitSizing(state.dataSize->CurTermUnitSizingNum).ReheatLoadMult);
         }
     }
 
@@ -3020,6 +3152,9 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
     if (this->MaxReheatWaterVolFlow == AutoSize) {
         IsAutoSize = true;
     }
+
+    Real64 DesCoilLoad = 0.0;
+    
     if (state.dataSize->CurTermUnitSizingNum > 0) {
         if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) {
             if (this->MaxReheatWaterVolFlow > 0.0) {
@@ -3028,36 +3163,30 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
             }
         } else {
             CheckZoneSizing(state, this->sysType, this->SysName);
-            if (Util::SameString(this->ReheatComp, "Coil:Heating:Water")) {
-                state.dataSingleDuct->CoilWaterInletNodeSS = GetCoilWaterInletNode(state, "Coil:Heating:Water", this->ReheatName, ErrorsFound);
-                state.dataSingleDuct->CoilWaterOutletNodeSS = GetCoilWaterOutletNode(state, "Coil:Heating:Water", this->ReheatName, ErrorsFound);
+            if (this->reheatCoilType == HVAC::CoilType::HeatingWater) {
+                int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, this->ReheatCoilNum);
+                int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, this->ReheatCoilNum);
                 if (IsAutoSize) {
                     PlantSizingErrorsFound = false;
                     PltSizHeatNum = MyPlantSizingIndex(state,
                                                        "Coil:Heating:Water",
-                                                       this->ReheatName,
-                                                       state.dataSingleDuct->CoilWaterInletNodeSS,
-                                                       state.dataSingleDuct->CoilWaterOutletNodeSS,
+                                                       this->ReheatCoilName,
+                                                       CoilWaterInletNode,
+                                                       CoilWaterOutletNode,
                                                        PlantSizingErrorsFound);
                     if (PlantSizingErrorsFound) {
                         ShowContinueError(state, format("...Occurs in {}:{}", this->sysType, this->SysName));
                         ErrorsFound = true;
                     }
                     if (PltSizHeatNum > 0) {
-                        state.dataSingleDuct->CoilInTempSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU;
+                        Real64 CoilInTemp = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU;
                         DesMassFlow = state.dataEnvrn->StdRhoAir * TermUnitSizing(state.dataSize->CurTermUnitSizingNum).AirVolFlow;
-                        state.dataSingleDuct->DesZoneHeatLoadSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).NonAirSysDesHeatLoad;
-                        state.dataSingleDuct->ZoneDesTempSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneTempAtHeatPeak;
-                        state.dataSingleDuct->ZoneDesHumRatSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneHumRatAtHeatPeak;
+                        Real64 DesZoneHeatLoad = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).NonAirSysDesHeatLoad;
+                        Real64 ZoneDesTemp = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneTempAtHeatPeak;
+                        Real64 ZoneDesHumRat = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneHumRatAtHeatPeak;
                         // the coil load is the zone design heating load plus (or minus!) the reheat load
-                        state.dataSingleDuct->DesCoilLoadSS =
-                            state.dataSingleDuct->DesZoneHeatLoadSS + PsyCpAirFnW(state.dataSingleDuct->ZoneDesHumRatSS) * DesMassFlow *
-                                                                          (state.dataSingleDuct->ZoneDesTempSS - state.dataSingleDuct->CoilInTempSS);
-                        if (state.dataSingleDuct->DesCoilLoadSS >= SmallLoad) {
+                        DesCoilLoad = DesZoneHeatLoad + PsyCpAirFnW(ZoneDesHumRat) * DesMassFlow * (ZoneDesTemp - CoilInTemp);
+                        if (DesCoilLoad >= SmallLoad) {
 
                             rho =
                                 state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
@@ -3065,8 +3194,7 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
                             Cp = state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum)
                                      .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName);
 
-                            MaxReheatWaterVolFlowDes =
-                                state.dataSingleDuct->DesCoilLoadSS / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho);
+                            MaxReheatWaterVolFlowDes = DesCoilLoad / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho);
                         } else {
                             MaxReheatWaterVolFlowDes = 0.0;
                         }
@@ -3139,36 +3267,31 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
             }
         } else {
             CheckZoneSizing(state, this->sysType, this->SysName);
-            if (Util::SameString(this->ReheatComp, "Coil:Heating:Steam")) {
-                state.dataSingleDuct->CoilSteamInletNodeSS = GetCoilSteamInletNode(state, "Coil:Heating:Steam", this->ReheatName, ErrorsFound);
-                state.dataSingleDuct->CoilSteamOutletNodeSS = GetCoilSteamOutletNode(state, "Coil:Heating:Steam", this->ReheatName, ErrorsFound);
+            if (this->reheatCoilType == HVAC::CoilType::HeatingSteam) {
+                // Why are these state variables?
+                int CoilSteamInletNode = SteamCoils::GetCoilSteamInletNode(state, this->ReheatCoilNum);
+                int CoilSteamOutletNode = SteamCoils::GetCoilSteamOutletNode(state, this->ReheatCoilNum);
                 if (IsAutoSize) {
                     PlantSizingErrorsFound = false;
                     PltSizHeatNum = MyPlantSizingIndex(state,
-                                                       "Coil:Heating:Steam",
-                                                       this->ReheatName,
-                                                       state.dataSingleDuct->CoilSteamInletNodeSS,
-                                                       state.dataSingleDuct->CoilSteamOutletNodeSS,
+                                                       HVAC::coilTypeNames[(int)this->reheatCoilType],
+                                                       this->ReheatCoilName,
+                                                       CoilSteamInletNode,
+                                                       CoilSteamOutletNode,
                                                        PlantSizingErrorsFound);
                     if (PlantSizingErrorsFound) {
                         ShowContinueError(state, format("...Occurs in {}:{}", this->sysType, this->SysName));
                         ErrorsFound = true;
                     }
                     if (PltSizHeatNum > 0) {
-                        state.dataSingleDuct->CoilInTempSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU;
+                        Real64 CoilInTemp = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).DesHeatCoilInTempTU;
                         DesMassFlow = state.dataEnvrn->StdRhoAir * TermUnitSizing(state.dataSize->CurTermUnitSizingNum).AirVolFlow;
-                        state.dataSingleDuct->DesZoneHeatLoadSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).NonAirSysDesHeatLoad;
-                        state.dataSingleDuct->ZoneDesTempSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneTempAtHeatPeak;
-                        state.dataSingleDuct->ZoneDesHumRatSS =
-                            state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneHumRatAtHeatPeak;
+                        Real64 DesZoneHeatLoad = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).NonAirSysDesHeatLoad;
+                        Real64 ZoneDesTemp = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneTempAtHeatPeak;
+                        Real64 ZoneDesHumRat = state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneHumRatAtHeatPeak;
                         // the coil load is the zone design heating load plus (or minus!) the reheat load
-                        state.dataSingleDuct->DesCoilLoadSS =
-                            state.dataSingleDuct->DesZoneHeatLoadSS + PsyCpAirFnW(state.dataSingleDuct->ZoneDesHumRatSS) * DesMassFlow *
-                                                                          (state.dataSingleDuct->ZoneDesTempSS - state.dataSingleDuct->CoilInTempSS);
-                        if (state.dataSingleDuct->DesCoilLoadSS >= SmallLoad) {
+                        DesCoilLoad = DesZoneHeatLoad + PsyCpAirFnW(ZoneDesHumRat) * DesMassFlow * (ZoneDesTemp - CoilInTemp);
+                        if (DesCoilLoad >= SmallLoad) {
                             TempSteamIn = 100.00;
                             auto *steam = Fluid::GetSteam(state);
                             EnthSteamInDry = steam->getSatEnthalpy(state, TempSteamIn, 1.0, RoutineNameFull);
@@ -3177,7 +3300,7 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
                             SteamDensity = steam->getSatDensity(state, TempSteamIn, 1.0, RoutineNameFull);
 
                             Cp = Fluid::GetWater(state)->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp, RoutineName);
-                            MaxReheatSteamVolFlowDes = state.dataSingleDuct->DesCoilLoadSS /
+                            MaxReheatSteamVolFlowDes = DesCoilLoad /
                                                        (SteamDensity * (LatentHeatSteam + state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp));
                         } else {
                             MaxReheatSteamVolFlowDes = 0.0;
@@ -3228,13 +3351,12 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state)
         TermUnitSizing(state.dataSize->CurTermUnitSizingNum).MinPriFlowFrac = this->ZoneMinAirFracDes * this->ZoneTurndownMinAirFrac;
         TermUnitSizing(state.dataSize->CurTermUnitSizingNum).MaxHWVolFlow = this->MaxReheatWaterVolFlow;
         TermUnitSizing(state.dataSize->CurTermUnitSizingNum).MaxSTVolFlow = this->MaxReheatSteamVolFlow;
-        TermUnitSizing(state.dataSize->CurTermUnitSizingNum).DesHeatingLoad = state.dataSingleDuct->DesCoilLoadSS; // Coil Summary report
-        if (this->ReheatComp_Num == HeatingCoilType::SimpleHeating) {
+        TermUnitSizing(state.dataSize->CurTermUnitSizingNum).DesHeatingLoad = DesCoilLoad; // Coil Summary report
+        if (this->reheatCoilType == HVAC::CoilType::HeatingWater) {
             if (this->DamperHeatingAction == Action::Normal) {
-                SetCoilDesFlow(state, this->ReheatComp, this->ReheatName, this->ZoneMinAirFracDes * this->MaxAirVolFlowRate, ErrorsFound);
+                WaterCoils::SetCoilDesFlow(state, this->ReheatCoilNum, this->ZoneMinAirFracDes * this->MaxAirVolFlowRate);
             } else {
-                SetCoilDesFlow(
-                    state, this->ReheatComp, this->ReheatName, TermUnitSizing(state.dataSize->CurTermUnitSizingNum).AirVolFlow, ErrorsFound);
+                WaterCoils::SetCoilDesFlow(state, this->ReheatCoilNum, TermUnitSizing(state.dataSize->CurTermUnitSizingNum).AirVolFlow);
             }
         }
     }
@@ -3295,11 +3417,8 @@ void SingleDuctAirTerminal::SimVAV(EnergyPlusData &state, bool const FirstHVACIt
     // Using/Aliasing
     using namespace DataZoneEnergyDemands;
     // unused   USE DataHeatBalFanSys, ONLY: Mat
-    using HeatingCoils::SimulateHeatingCoilComponents;
     using HVAC::SmallLoad;
     using PlantUtilities::SetActuatedBranchFlowRate;
-    using SteamCoils::SimulateSteamCoilComponents;
-    using WaterCoils::SimulateWaterCoilComponents;
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
     Real64 MassFlow;     // [kg/sec]   Total Mass Flow Rate from Hot & Cold Inlets
@@ -3534,9 +3653,9 @@ void SingleDuctAirTerminal::SimVAV(EnergyPlusData &state, bool const FirstHVACIt
         this->UpdateSys(state);
 
         // Now do the heating coil calculation for each heating coil type
-        switch (this->ReheatComp_Num) { // Reverse damper option is working only for water coils for now.
+        switch (this->reheatCoilType) { // Reverse damper option is working only for water coils for now.
             // hot water heating coil
-        case HeatingCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+        case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
             // Determine the load required to pass to the Component controller
             // Although this equation looks strange (using temp instead of deltaT), it is corrected later in ControlCompOutput
             // and is working as-is, temperature setpoints are maintained as expected.
@@ -3560,9 +3679,9 @@ void SingleDuctAirTerminal::SimVAV(EnergyPlusData &state, bool const FirstHVACIt
             // hot water flow rate.
             // FB use QActualHeating, change ControlCompOutput to use new
             ControlCompOutput(state,
-                              this->ReheatName,
-                              this->ReheatComp,
-                              this->ReheatComp_Index,
+                              this->ReheatCoilName,
+                              HVAC::coilTypeNames[(int)this->reheatCoilType],
+                              this->ReheatCoilNum,
                               FirstHVACIteration,
                               QZnReq,
                               this->ReheatControlNode,
@@ -3584,6 +3703,8 @@ void SingleDuctAirTerminal::SimVAV(EnergyPlusData &state, bool const FirstHVACIt
             if (this->DamperHeatingAction == Action::Reverse || this->DamperHeatingAction == Action::ReverseWithLimits) {
                 if (state.dataLoopNodes->Node(this->ReheatControlNode).MassFlowRate == MaxFlowWater) {
                     // fill limits for air flow for controller
+
+                    // Why are all of these state variables?
                     state.dataSingleDuct->MinAirMassFlowRevActSVAV = this->AirMassFlowRateMax * this->ZoneMinAirFrac;
                     state.dataSingleDuct->MinAirMassFlowRevActSVAV =
                         min(state.dataSingleDuct->MinAirMassFlowRevActSVAV, this->sd_airterminalInlet.AirMassFlowRateMaxAvail);
@@ -3601,9 +3722,9 @@ void SingleDuctAirTerminal::SimVAV(EnergyPlusData &state, bool const FirstHVACIt
                     state.dataLoopNodes->Node(this->OutletNodeNum).MassFlowRateMaxAvail =
                         state.dataSingleDuct->MaxAirMassFlowRevActSVAV; // suspect, check how/if used in ControlCompOutput
                     ControlCompOutput(state,
-                                      this->ReheatName,
-                                      this->ReheatComp,
-                                      this->ReheatComp_Index,
+                                      this->ReheatCoilName,
+                                      HVAC::coilTypeNames[(int)this->reheatCoilType],
+                                      this->ReheatCoilNum,
                                       FirstHVACIteration,
                                       state.dataSingleDuct->QZoneMax2SDAT,
                                       this->OutletNodeNum,
@@ -3632,9 +3753,9 @@ void SingleDuctAirTerminal::SimVAV(EnergyPlusData &state, bool const FirstHVACIt
                         // and is working as-is, temperature setpoints are maintained as expected.
                         QZnReq = state.dataSingleDuct->QZoneMax2SDAT + MassFlow * CpAirAvg * state.dataSingleDuct->ZoneTempSDAT;
                         ControlCompOutput(state,
-                                          this->ReheatName,
-                                          this->ReheatComp,
-                                          this->ReheatComp_Index,
+                                          this->ReheatCoilName,
+                                          HVAC::coilTypeNames[(int)this->reheatCoilType],
+                                          this->ReheatCoilNum,
                                           FirstHVACIteration,
                                           QZnReq,
                                           this->ReheatControlNode,
@@ -3669,68 +3790,63 @@ void SingleDuctAirTerminal::SimVAV(EnergyPlusData &state, bool const FirstHVACIt
                 this->ZoneMinAirFracReport = this->ZoneMinAirFrac;
             }
         } break;
-        case HeatingCoilType::SteamAirHeating: { // ! COIL:STEAM:AIRHEATING
+          
+        case HVAC::CoilType::HeatingSteam: { // ! COIL:STEAM:AIRHEATING
             // Determine the load required to pass to the Component controller
             QZnReq =
                 state.dataSingleDuct->QZoneMax2SDAT - MassFlow * CpAirAvg * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSDAT);
 
             // Simulate reheat coil for the VAV system
-            SimulateSteamCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index, QZnReq);
+            SteamCoils::SimulateSteamCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum, QZnReq);
         } break;
-        case HeatingCoilType::Electric: { // COIL:ELECTRIC:HEATING
-            // Determine the load required to pass to the Component controller
-            QZnReq =
-                state.dataSingleDuct->QZoneMax2SDAT - MassFlow * CpAirAvg * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSDAT);
 
-            // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, QZnReq, this->ReheatComp_Index);
-        } break;
-        case HeatingCoilType::Gas: { // COIL:GAS:HEATING
+        case HVAC::CoilType::HeatingElectric:  // COIL:ELECTRIC:HEATING
+        case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
             // Determine the load required to pass to the Component controller
             QZnReq =
                 state.dataSingleDuct->QZoneMax2SDAT - MassFlow * CpAirAvg * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSDAT);
 
             // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, QZnReq, this->ReheatComp_Index, QHeatingDelivered);
+            HeatingCoils::SimulateHeatingCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, QZnReq, this->ReheatCoilNum);
         } break;
-        case HeatingCoilType::None: { // blank
-                                      // I no reheat is defined then assume that the damper is the only component.
+          
+        case HVAC::CoilType::Invalid: { // blank
+            // I no reheat is defined then assume that the damper is the only component.
             // If something else is there that is not a reheat coil or a blank then give the error message
         } break;
         default: {
-            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
         } break;
         }
 
         // the COIL is OFF the properties are calculated for this special case.
     } else {
-        switch (this->ReheatComp_Num) {
-        case HeatingCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+        switch (this->reheatCoilType) {
+        case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
             // Simulate reheat coil for the Const Volume system
             DummyMdot = 0.0;
             SetActuatedBranchFlowRate(state, DummyMdot, this->ReheatControlNode, this->HWplantLoc, true);
             // call the reheat coil with the NO FLOW condition to make sure that the Node values
             // are passed through to the coil outlet correctly
-            SimulateWaterCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index);
+            WaterCoils::SimulateWaterCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum);
         } break;
-        case HeatingCoilType::SteamAirHeating: { // COIL:STEAM:AIRHEATING
+        case HVAC::CoilType::HeatingSteam: { // COIL:STEAM:AIRHEATING
             // Simulate reheat coil for the VAV system
-            SimulateSteamCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index, 0.0);
+            SteamCoils::SimulateSteamCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum, 0.0);
         } break;
-        case HeatingCoilType::Electric: { // COIL:ELECTRIC:HEATING
-            // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, 0.0, this->ReheatComp_Index);
-        } break;
-        case HeatingCoilType::Gas: { // COIL:GAS:HEATING
-            // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, 0.0, this->ReheatComp_Index);
+        case HVAC::CoilType::HeatingElectric:  // COIL:ELECTRIC:HEATING
+        case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
+          // Simulate reheat coil for the VAV system
+            HeatingCoils::SimulateHeatingCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, 0.0, this->ReheatCoilNum);
         } break;
-        case HeatingCoilType::None: { // blank
-                                      // If no reheat is defined then assume that the damper is the only component.
-                                      // If something else is that is not a reheat coil or a blank then give the error message
+
+        case HVAC::CoilType::Invalid: { // blank
+            // I no reheat is defined then assume that the damper is the only component.
+            // If something else is there that is not a reheat coil or a blank then give the error message
         } break;
+          
         default: {
-            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
         } break;
         }
     }
@@ -3807,9 +3923,6 @@ void SingleDuctAirTerminal::SimCBVAV(EnergyPlusData &state, bool const FirstHVAC
     using namespace DataZoneEnergyDemands;
     using HVAC::SmallLoad;
     // unused   USE DataHeatBalFanSys,    ONLY: Mat
-    using HeatingCoils::SimulateHeatingCoilComponents;
-    using SteamCoils::SimulateSteamCoilComponents;
-    using WaterCoils::SimulateWaterCoilComponents;
     // unused   USE DataHeatBalFanSys,    ONLY: ZoneThermostatSetPointHi, ZoneThermostatSetPointLo
     using PlantUtilities::SetActuatedBranchFlowRate;
 
@@ -3953,8 +4066,8 @@ void SingleDuctAirTerminal::SimCBVAV(EnergyPlusData &state, bool const FirstHVAC
 
         this->UpdateSys(state);
 
-        switch (this->ReheatComp_Num) {        // hot water heating coil
-        case HeatingCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+        switch (this->reheatCoilType) {        // hot water heating coil
+        case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
             // Determine the load required to pass to the Component controller
             // Although this equation looks strange (using temp instead of deltaT), it is corrected later in ControlCompOutput
             // and is working as-is, temperature setpoints are maintained as expected.
@@ -3979,9 +4092,9 @@ void SingleDuctAirTerminal::SimCBVAV(EnergyPlusData &state, bool const FirstHVAC
             // Simulate the reheat coil at constant air flow. Control by varying the
             // hot water flow rate.
             ControlCompOutput(state,
-                              this->ReheatName,
-                              this->ReheatComp,
-                              this->ReheatComp_Index,
+                              this->ReheatCoilName,
+                              HVAC::coilTypeNames[(int)this->reheatCoilType],
+                              this->ReheatCoilNum,
                               FirstHVACIteration,
                               QZnReq,
                               this->ReheatControlNode,
@@ -4003,9 +4116,9 @@ void SingleDuctAirTerminal::SimCBVAV(EnergyPlusData &state, bool const FirstHVAC
             if (this->DamperHeatingAction == Action::Reverse) {
                 if (state.dataLoopNodes->Node(this->ReheatControlNode).MassFlowRate == this->MaxReheatWaterFlow) {
                     ControlCompOutput(state,
-                                      this->ReheatName,
-                                      this->ReheatComp,
-                                      this->ReheatComp_Index,
+                                      this->ReheatCoilName,
+                                      HVAC::coilTypeNames[(int)this->reheatCoilType],
+                                      this->ReheatCoilNum,
                                       FirstHVACIteration,
                                       state.dataSingleDuct->QZoneMax2SCBVAV,
                                       this->OutletNodeNum,
@@ -4031,9 +4144,9 @@ void SingleDuctAirTerminal::SimCBVAV(EnergyPlusData &state, bool const FirstHVAC
                     this->sd_airterminalOutlet.AirMassFlowRate = MassFlow;
                     this->UpdateSys(state);
                     ControlCompOutput(state,
-                                      this->ReheatName,
-                                      this->ReheatComp,
-                                      this->ReheatComp_Index,
+                                      this->ReheatCoilName,
+                                      HVAC::coilTypeNames[(int)this->reheatCoilType],
+                                      this->ReheatCoilNum,
                                       FirstHVACIteration,
                                       QZnReq,
                                       this->ReheatControlNode,
@@ -4057,46 +4170,41 @@ void SingleDuctAirTerminal::SimCBVAV(EnergyPlusData &state, bool const FirstHVAC
                 }
             }
         } break;
-        case HeatingCoilType::SteamAirHeating: { // ! COIL:STEAM:AIRHEATING
+
+        case HVAC::CoilType::HeatingSteam: { // ! COIL:STEAM:AIRHEATING
             // Determine the load required to pass to the Component controller
             QZnReq = state.dataSingleDuct->QZoneMax2SCBVAV -
                      MassFlow * CpAirZn * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSCBVAV);
             if (QZnReq < SmallLoad) QZnReq = 0.0;
 
             // Simulate reheat coil for the VAV system
-            SimulateSteamCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index, QZnReq);
+            SteamCoils::SimulateSteamCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum, QZnReq);
         } break;
-        case HeatingCoilType::Electric: { // COIL:ELECTRIC:HEATING
+          
+        case HVAC::CoilType::HeatingElectric:  // COIL:ELECTRIC:HEATING
+        case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
             // Determine the load required to pass to the Component controller
             QSupplyAir = MassFlow * CpAirZn * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSCBVAV);
             QZnReq = state.dataSingleDuct->QZoneMax2SCBVAV - QSupplyAir;
             if (QZnReq < SmallLoad) QZnReq = 0.0;
 
             // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, QZnReq, this->ReheatComp_Index);
+            HeatingCoils::SimulateHeatingCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, QZnReq, this->ReheatCoilNum);
         } break;
-        case HeatingCoilType::Gas: { // COIL:GAS:HEATING
-            // Determine the load required to pass to the Component controller
-            QZnReq = state.dataSingleDuct->QZoneMax2SCBVAV -
-                     MassFlow * CpAirZn * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSCBVAV);
-            if (QZnReq < SmallLoad) QZnReq = 0.0;
 
-            // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, QZnReq, this->ReheatComp_Index);
-        } break;
-        case HeatingCoilType::None: { // blank
+        case HVAC::CoilType::Invalid: { // blank
                                       // If no reheat is defined then assume that the damper is the only component.
             // If something else is there that is not a reheat coil then give the error message below.
         } break;
         default: {
-            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
         } break;
         }
 
         // the COIL is OFF the properties are calculated for this special case.
     } else {
-        switch (this->ReheatComp_Num) {
-        case HeatingCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+        switch (this->reheatCoilType) {
+        case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
             // Simulate reheat coil for the Const Volume system
             // Node(sd_airterminal(SysNum)%ReheatControlNode)%MassFlowRate = 0.0D0
             // Initialize hot water flow rate to zero.
@@ -4105,26 +4213,26 @@ void SingleDuctAirTerminal::SimCBVAV(EnergyPlusData &state, bool const FirstHVAC
 
             // call the reheat coil with the NO FLOW condition to make sure that the Node values
             // are passed through to the coil outlet correctly
-            SimulateWaterCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index);
-        } break;
-        case HeatingCoilType::SteamAirHeating: { // COIL:STEAM:AIRHEATING
-            // Simulate reheat coil for the VAV system
-            SimulateSteamCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index, 0.0);
+            WaterCoils::SimulateWaterCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum);
         } break;
-        case HeatingCoilType::Electric: { // COIL:ELECTRIC:HEATING
+          
+        case HVAC::CoilType::HeatingSteam: { // COIL:STEAM:AIRHEATING
             // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, 0.0, this->ReheatComp_Index);
+            SteamCoils::SimulateSteamCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum, 0.0);
         } break;
-        case HeatingCoilType::Gas: { // COIL:GAS:HEATING
+          
+        case HVAC::CoilType::HeatingElectric:  // COIL:ELECTRIC:HEATING
+        case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
             // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, 0.0, this->ReheatComp_Index);
+            HeatingCoils::SimulateHeatingCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, 0.0, this->ReheatCoilNum);
         } break;
-        case HeatingCoilType::None: { // blank
+
+        case HVAC::CoilType::Invalid: { // blank
                                       // If no reheat is defined then assume that the damper is the only component.
                                       // If something else is there that is not a reheat coil then give the error message
         } break;
         default: {
-            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
         } break;
         }
     }
@@ -4153,7 +4261,6 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
     // Using/Aliasing
     using namespace DataZoneEnergyDemands;
     using General::SolveRoot;
-    using SteamCoils::GetCoilCapacity;
 
     // SUBROUTINE PARAMETER DEFINITIONS:
     Real64 constexpr BigLoad(1.0e+20);
@@ -4180,7 +4287,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
     Real64 QHeatFanOnMin;   // min heating - fan at min flow, hot water at max flow [W]
     Real64 QHeatFanOffMax;  // max heating - fan off, hot water flow at max [W]
     Real64 QNoHeatFanOff;   // min heating - fan off, hot water at min flow [W]
-    HeatingCoilType HCType; // heating coil type
+    HVAC::CoilType heatCoilType; // heating coil type
     HVAC::FanType fanType;  // fan type (as a number)
     int FanOp;              // 1 if fan is on; 0 if off.
     Real64 MaxCoolMassFlow; // air flow at max cooling [kg/s]
@@ -4198,7 +4305,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
     SysOutletNode = this->ReheatAirOutletNode;
     SysInletNode = this->InletNodeNum;
     CpAirZn = PsyCpAirFnW(state.dataLoopNodes->Node(ZoneNodeNum).HumRat);
-    HCType = this->ReheatComp_Num;
+    heatCoilType = this->reheatCoilType;
     fanType = this->fanType;
     MaxCoolMassFlow = this->sd_airterminalInlet.AirMassFlowRateMaxAvail;
     MaxHeatMassFlow = min(this->HeatAirMassFlowRateMax, this->sd_airterminalInlet.AirMassFlowRateMaxAvail);
@@ -4213,7 +4320,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
         return;
     }
 
-    if (HCType == HeatingCoilType::SimpleHeating) {
+    if (heatCoilType == HVAC::CoilType::HeatingWater) {
         WaterControlNode = this->ReheatControlNode;
         if (FirstHVACIteration) {
             MaxFlowWater = this->MaxReheatWaterFlow;
@@ -4229,7 +4336,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
         MinFlowWater = 0.0;
     }
 
-    if (HCType == HeatingCoilType::SteamAirHeating) {
+    if (heatCoilType == HVAC::CoilType::HeatingSteam) {
         SteamControlNode = this->ReheatControlNode;
         if (FirstHVACIteration) {
             MaxFlowSteam = this->MaxReheatSteamFlow;
@@ -4247,13 +4354,13 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
     // define 3 load regions and assign the current load to the correct region.
     // region 1: active cooling with fan on
     FanOp = 1;
-    if (HCType == HeatingCoilType::SteamAirHeating) {
+    if (heatCoilType == HVAC::CoilType::HeatingSteam) {
         bool ErrorsFound; // returned from mining function call
         this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MinFlowSteam, 0.0, fanType, MaxCoolMassFlow, FanOp, QCoolFanOnMax);
         this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MinFlowSteam, 0.0, fanType, MinMassFlow, FanOp, QCoolFanOnMin);
         // region 2: active heating with fan on
         this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MaxFlowSteam, BigLoad, fanType, MaxHeatMassFlow, FanOp, QHeatFanOnMax);
-        MaxSteamCap = GetCoilCapacity(state, this->ReheatComp, this->ReheatName, ErrorsFound);
+        MaxSteamCap = SteamCoils::GetCoilCapacity(state, this->ReheatCoilNum);
         this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MaxFlowSteam, 0.0, fanType, MinMassFlow, FanOp, QHeatFanOnMin);
         // region 3: active heating with fan off
         FanOp = 0;
@@ -4277,7 +4384,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
         // check that it can meet the load
         FanOp = 1;
         if (QCoolFanOnMax < QTotLoad - SmallLoad) {
-            Real64 MinHWFlow = (HCType == HeatingCoilType::SteamAirHeating) ? MinFlowSteam : MinFlowWater;
+            Real64 MinHWFlow = (heatCoilType == HVAC::CoilType::HeatingSteam) ? MinFlowSteam : MinFlowWater;
 
             auto f = [&state, this, FirstHVACIteration, ZoneNodeNum, MinHWFlow, fanType, FanOp, QTotLoad](Real64 const SupplyAirMassFlow) {
                 Real64 UnitOutput = 0.0; // cooling output [W] (cooling is negative)
@@ -4308,7 +4415,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
 
             MassFlow = MaxCoolMassFlow;
 
-            if (HCType == HeatingCoilType::SteamAirHeating) {
+            if (heatCoilType == HVAC::CoilType::HeatingSteam) {
                 this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MinFlowSteam, 0.0, fanType, MassFlow, FanOp, QDelivered);
             } else {
                 this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MinFlowWater, 0.0, fanType, MassFlow, FanOp, QDelivered);
@@ -4321,7 +4428,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
                (this->sd_airterminalInlet.AirMassFlowRateMaxAvail > 0.0 && state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum))) {
         MassFlow = MinMassFlow;
         FanOp = 0;
-        if (HCType == HeatingCoilType::SteamAirHeating) {
+        if (heatCoilType == HVAC::CoilType::HeatingSteam) {
             this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MinFlowSteam, QTotLoad, fanType, MassFlow, FanOp, QNoHeatFanOff);
         } else {
             this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MinFlowWater, 0.0, fanType, MassFlow, FanOp, QNoHeatFanOff);
@@ -4331,7 +4438,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
     } else if (QTotLoad > QNoHeatFanOff + SmallLoad && this->sd_airterminalInlet.AirMassFlowRateMaxAvail > 0.0 &&
                !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
         // hot water coil
-        if (HCType == HeatingCoilType::SimpleHeating) {
+        if (heatCoilType == HVAC::CoilType::HeatingWater) {
             if (QTotLoad < QHeatFanOffMax - SmallLoad) {
                 // vary HW flow, leave air flow at minimum
                 ErrTolerance = this->ControllerOffset;
@@ -4393,7 +4500,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
                 FanOp = 1;
                 this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, MaxFlowWater, 0.0, fanType, MassFlow, FanOp, QDelivered);
             }
-        } else if (HCType == HeatingCoilType::SteamAirHeating) {
+        } else if (heatCoilType == HVAC::CoilType::HeatingSteam) {
             //      IF (QTotLoad > QNoHeatFanOff + SmallLoad .AND. QTotLoad < QHeatFanOffMax - SmallLoad) THEN
             if (QTotLoad < QHeatFanOffMax - SmallLoad) {
                 ErrTolerance = this->ControllerOffset;
@@ -4463,7 +4570,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
                 FanOp = 1;
                 this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, QTotLoad, QTotLoad, fanType, MassFlow, FanOp, QDelivered);
             }
-        } else if (HCType == HeatingCoilType::Gas || HCType == HeatingCoilType::Electric) {
+        } else if (heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel || heatCoilType == HVAC::CoilType::HeatingElectric) {
             if (QTotLoad <= QHeatFanOnMin + SmallLoad) {
                 // vary heating coil power, leave mass flow at minimum
                 MassFlow = MinMassFlow;
@@ -4512,7 +4619,7 @@ void SingleDuctAirTerminal::SimVAVVS(EnergyPlusData &state, bool const FirstHVAC
                 this->CalcVAVVS(state, FirstHVACIteration, ZoneNodeNum, 0.0, QTotLoad, fanType, MassFlow, FanOp, QDelivered);
             }
         } else {
-            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
         }
 
     } else {
@@ -4551,10 +4658,7 @@ void SingleDuctAirTerminal::SimConstVol(EnergyPlusData &state, bool const FirstH
     // Using/Aliasing
     using namespace DataZoneEnergyDemands;
     // unused   USE DataHeatBalFanSys, ONLY: Mat
-    using HeatingCoils::SimulateHeatingCoilComponents;
     using PlantUtilities::SetActuatedBranchFlowRate;
-    using SteamCoils::SimulateSteamCoilComponents;
-    using WaterCoils::SimulateWaterCoilComponents;
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
     Real64 MaxFlowWater; // This is the value passed to the Controller depending if FirstHVACIteration or not
@@ -4600,8 +4704,8 @@ void SingleDuctAirTerminal::SimConstVol(EnergyPlusData &state, bool const FirstH
 
         Real64 QZnReq;
 
-        switch (this->ReheatComp_Num) {
-        case HeatingCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+        switch (this->reheatCoilType) {
+        case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
             // Determine the load required to pass to the Component controller
             QZnReq = state.dataSingleDuct->QMax2SCV + MassFlow * CpAir * state.dataSingleDuct->ZoneTempSCV;
 
@@ -4626,9 +4730,9 @@ void SingleDuctAirTerminal::SimConstVol(EnergyPlusData &state, bool const FirstH
             // Simulate reheat coil for the Const Volume system
             // Set Converged to True & when controller is not converged it will set to False.
             ControlCompOutput(state,
-                              this->ReheatName,
-                              this->ReheatComp,
-                              this->ReheatComp_Index,
+                              this->ReheatCoilName,
+                              HVAC::coilTypeNames[(int)this->reheatCoilType],
+                              this->ReheatCoilNum,
                               FirstHVACIteration,
                               QZnReq,
                               this->ReheatControlNode,
@@ -4645,37 +4749,33 @@ void SingleDuctAirTerminal::SimConstVol(EnergyPlusData &state, bool const FirstH
                               this->HWplantLoc);
 
         } break;
-        case HeatingCoilType::SteamAirHeating: { // COIL:STEAM:STEAMAIRHEATING
+        case HVAC::CoilType::HeatingSteam: { // COIL:STEAM:STEAMAIRHEATING
             // Determine the load required to pass to the Component controller
             QZnReq = state.dataSingleDuct->QMax2SCV - MassFlow * CpAir * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSCV);
 
             // Simulate reheat coil for the VAV system
-            SimulateSteamCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index, QZnReq);
+            SteamCoils::SimulateSteamCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum, QZnReq);
         } break;
-        case HeatingCoilType::Electric: { // COIL:ELECTRIC:HEATING
+
+        case HVAC::CoilType::HeatingElectric:  // COIL:ELECTRIC:HEATING
+        case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
             // Determine the load required to pass to the Component controller
             QZnReq = state.dataSingleDuct->QMax2SCV - MassFlow * CpAir * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSCV);
 
             // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, QZnReq, this->ReheatComp_Index);
+            HeatingCoils::SimulateHeatingCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, QZnReq, this->ReheatCoilNum);
 
         } break;
-        case HeatingCoilType::Gas: { // COIL:GAS:HEATING
-            // Determine the load required to pass to the Component controller
-            QZnReq = state.dataSingleDuct->QMax2SCV - MassFlow * CpAir * (this->sd_airterminalInlet.AirTemp - state.dataSingleDuct->ZoneTempSCV);
 
-            // Simulate reheat coil for the VAV system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, QZnReq, this->ReheatComp_Index);
-        } break;
         default: {
-            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
         } break;
         }
 
         // the COIL is OFF the properties are calculated for this special case.
     } else {
-        switch (this->ReheatComp_Num) {
-        case HeatingCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+        switch (this->reheatCoilType) {
+        case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
             // Simulate reheat coil for the Const Volume system
             // Node(sd_airterminal(SysNum)%ReheatControlNode)%MassFlowRate = 0.0D0
             // Initialize hot water flow rate to zero.
@@ -4684,22 +4784,22 @@ void SingleDuctAirTerminal::SimConstVol(EnergyPlusData &state, bool const FirstH
 
             // call the reheat coil with the NO FLOW condition to make sure that the Node values
             // are passed through to the coil outlet correctly
-            SimulateWaterCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index);
+            WaterCoils::SimulateWaterCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum);
         } break;
-        case HeatingCoilType::SteamAirHeating: { // COIL:STEAM:AIRHEATING
+          
+        case HVAC::CoilType::HeatingSteam: { // COIL:STEAM:AIRHEATING
             // Simulate reheat coil for the Const Volume system
-            SimulateSteamCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index, 0.0);
+            SteamCoils::SimulateSteamCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum, 0.0);
         } break;
-        case HeatingCoilType::Electric: { // COIL:ELECTRIC:HEATING
+          
+        case HVAC::CoilType::HeatingElectric: // COIL:ELECTRIC:HEATING
+        case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
             // Simulate reheat coil for the Const Volume system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, 0.0, this->ReheatComp_Index);
-        } break;
-        case HeatingCoilType::Gas: { // COIL:GAS:HEATING
-            // Simulate reheat coil for the Const Volume system
-            SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, 0.0, this->ReheatComp_Index);
+            HeatingCoils::SimulateHeatingCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, 0.0, this->ReheatCoilNum);
         } break;
+
         default: {
-            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+            ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
         } break;
         }
     }
@@ -4740,10 +4840,7 @@ void SingleDuctAirTerminal::CalcVAVVS(EnergyPlusData &state,
     // Simulates the unit components sequentially in the air flow direction.
 
     // Using/Aliasing
-    using HeatingCoils::SimulateHeatingCoilComponents;
     using PlantUtilities::SetComponentFlowRate;
-    using SteamCoils::SimulateSteamCoilComponents;
-    using WaterCoils::SimulateWaterCoilComponents;
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
     int FanInNode;       // unit air inlet node (fan inlet)
@@ -4774,30 +4871,31 @@ void SingleDuctAirTerminal::CalcVAVVS(EnergyPlusData &state,
         state.dataLoopNodes->Node(FanOutNode).MassFlowRateMaxAvail = state.dataLoopNodes->Node(FanInNode).MassFlowRateMaxAvail;
         state.dataLoopNodes->Node(FanOutNode).MassFlowRateMinAvail = state.dataLoopNodes->Node(FanInNode).MassFlowRateMinAvail;
     }
-    switch (this->ReheatComp_Num) {
-    case HeatingCoilType::SimpleHeating: { // COIL:WATER:SIMPLEHEATING
+
+    switch (this->reheatCoilType) {
+    case HVAC::CoilType::HeatingWater: { // COIL:WATER:SIMPLEHEATING
         mdot = HWFlow;
         if (this->HWplantLoc.loopNum > 0) {
             SetComponentFlowRate(state, mdot, this->ReheatControlNode, this->ReheatCoilOutletNode, this->HWplantLoc);
         }
 
-        SimulateWaterCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index);
+        WaterCoils::SimulateWaterCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum);
     } break;
-    case HeatingCoilType::SteamAirHeating: { // HW Flow is steam mass flow here
+      
+    case HVAC::CoilType::HeatingSteam: { // HW Flow is steam mass flow here
         mdot = HWFlow;
         if (this->HWplantLoc.loopNum > 0) {
             SetComponentFlowRate(state, mdot, this->ReheatControlNode, this->ReheatCoilOutletNode, this->HWplantLoc);
         }
-        SimulateSteamCoilComponents(state, this->ReheatName, FirstHVACIteration, this->ReheatComp_Index, HCoilReq);
+        SteamCoils::SimulateSteamCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, this->ReheatCoilNum, HCoilReq);
     } break;
-    case HeatingCoilType::Electric: { // COIL:ELECTRIC:HEATING
-        SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, HCoilReq, this->ReheatComp_Index);
-    } break;
-    case HeatingCoilType::Gas: { // COIL:GAS:HEATING
-        SimulateHeatingCoilComponents(state, this->ReheatName, FirstHVACIteration, HCoilReq, this->ReheatComp_Index);
+      
+    case HVAC::CoilType::HeatingElectric:  // COIL:ELECTRIC:HEATING
+    case HVAC::CoilType::HeatingGasOrOtherFuel: { // COIL:GAS:HEATING
+        HeatingCoils::SimulateHeatingCoilComponents(state, this->ReheatCoilName, FirstHVACIteration, HCoilReq, this->ReheatCoilNum);
     } break;
     default: {
-        ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatComp));
+        ShowFatalError(state, format("Invalid Reheat Component={}", this->ReheatCoilName));
     } break;
     }
 
@@ -5316,9 +5414,9 @@ void AirTerminalMixerData::InitATMixer(EnergyPlusData &state, bool const FirstHV
 {
     // Purpose: Initialize the AirTerminalMixers data structure with node data
     if (this->OneTimeInitFlag) {
-        {
+        { // Why is this a new scope?
             auto &thisADU(state.dataDefineEquipment->AirDistUnit(this->ADUNum));
-            {
+            { // Why is this a new scope?
                 auto &thisZoneEqConfig(state.dataZoneEquip->ZoneEquipConfig(thisADU.ZoneEqNum));
                 for (int SupAirIn = 1; SupAirIn <= thisZoneEqConfig.NumInletNodes; ++SupAirIn) {
                     if (this->ZoneInletNode == thisZoneEqConfig.InletNode(SupAirIn)) {
@@ -5328,13 +5426,13 @@ void AirTerminalMixerData::InitATMixer(EnergyPlusData &state, bool const FirstHV
                         thisZoneEqConfig.AirDistUnitHeat(SupAirIn).OutNode = this->MixedAirOutNode;
                         thisADU.TermUnitSizingNum = thisZoneEqConfig.AirDistUnitCool(SupAirIn).TermUnitSizingIndex;
                         this->CtrlZoneInNodeIndex = SupAirIn;
-                        {
+                        { // Why is this a new scope?
                             auto &thisTermUnitSizingData(state.dataSize->TermUnitSizing(thisADU.TermUnitSizingNum));
                             thisTermUnitSizingData.ADUName = thisADU.Name;
                             // Fill TermUnitSizing with specs from DesignSpecification:AirTerminal:Sizing if there is one attached to this
                             // terminal unit
                             if (thisADU.AirTerminalSizingSpecIndex > 0) {
-                                {
+                                { // Why is this a new scope?
                                     auto const &thisAirTermSizingSpec(state.dataSize->AirTerminalSizingSpec(thisADU.AirTerminalSizingSpecIndex));
                                     thisTermUnitSizingData.SpecDesCoolSATRatio = thisAirTermSizingSpec.DesCoolSATRatio;
                                     thisTermUnitSizingData.SpecDesHeatSATRatio = thisAirTermSizingSpec.DesHeatSATRatio;
@@ -5455,45 +5553,41 @@ void UpdateATMixer(EnergyPlusData &state, int const SysNum)
     // Using/Aliasing
     using namespace DataLoopNode;
 
-    // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-    int PriInNode = state.dataSingleDuct->SysATMixer(SysNum).PriInNode;
-    int SecInNode = state.dataSingleDuct->SysATMixer(SysNum).SecInNode;
-    int MixedAirOutNode = state.dataSingleDuct->SysATMixer(SysNum).MixedAirOutNode;
+    auto &atMixer = state.dataSingleDuct->SysATMixer(SysNum);
 
+    auto &priInNode = state.dataLoopNodes->Node(atMixer.PriInNode);
+    auto &secInNode = state.dataLoopNodes->Node(atMixer.SecInNode);
+    auto &mixedAirOutNode = state.dataLoopNodes->Node(atMixer.MixedAirOutNode);
     // mixed air data
-    state.dataLoopNodes->Node(MixedAirOutNode).Temp = state.dataSingleDuct->SysATMixer(SysNum).MixedAirTemp;
-    state.dataLoopNodes->Node(MixedAirOutNode).HumRat = state.dataSingleDuct->SysATMixer(SysNum).MixedAirHumRat;
-    state.dataLoopNodes->Node(MixedAirOutNode).Enthalpy = state.dataSingleDuct->SysATMixer(SysNum).MixedAirEnthalpy;
-    state.dataLoopNodes->Node(MixedAirOutNode).Press = state.dataSingleDuct->SysATMixer(SysNum).MixedAirPressure;
-    state.dataLoopNodes->Node(MixedAirOutNode).MassFlowRate = state.dataSingleDuct->SysATMixer(SysNum).MixedAirMassFlowRate;
+    mixedAirOutNode.Temp = atMixer.MixedAirTemp;
+    mixedAirOutNode.HumRat = atMixer.MixedAirHumRat;
+    mixedAirOutNode.Enthalpy = atMixer.MixedAirEnthalpy;
+    mixedAirOutNode.Press = atMixer.MixedAirPressure;
+    mixedAirOutNode.MassFlowRate = atMixer.MixedAirMassFlowRate;
 
     if (state.dataContaminantBalance->Contaminant.CO2Simulation) {
-        if (state.dataSingleDuct->SysATMixer(SysNum).MixedAirMassFlowRate <= HVAC::VerySmallMassFlow) {
-            state.dataLoopNodes->Node(MixedAirOutNode).CO2 = state.dataLoopNodes->Node(PriInNode).CO2;
+        if (atMixer.MixedAirMassFlowRate <= HVAC::VerySmallMassFlow) {
+            mixedAirOutNode.CO2 = priInNode.CO2;
         } else {
-            state.dataLoopNodes->Node(MixedAirOutNode).CO2 =
-                (state.dataLoopNodes->Node(SecInNode).MassFlowRate * state.dataLoopNodes->Node(SecInNode).CO2 +
-                 state.dataLoopNodes->Node(PriInNode).MassFlowRate * state.dataLoopNodes->Node(PriInNode).CO2) /
-                state.dataLoopNodes->Node(MixedAirOutNode).MassFlowRate;
+            mixedAirOutNode.CO2 =
+                (secInNode.MassFlowRate * secInNode.CO2 + priInNode.MassFlowRate * priInNode.CO2) / mixedAirOutNode.MassFlowRate;
         }
     }
 
     if (state.dataContaminantBalance->Contaminant.GenericContamSimulation) {
-        if (state.dataSingleDuct->SysATMixer(SysNum).MixedAirMassFlowRate <= HVAC::VerySmallMassFlow) {
-            state.dataLoopNodes->Node(MixedAirOutNode).GenContam = state.dataLoopNodes->Node(PriInNode).GenContam;
+        if (atMixer.MixedAirMassFlowRate <= HVAC::VerySmallMassFlow) {
+            mixedAirOutNode.GenContam = priInNode.GenContam;
         } else {
-            state.dataLoopNodes->Node(MixedAirOutNode).GenContam =
-                (state.dataLoopNodes->Node(SecInNode).MassFlowRate * state.dataLoopNodes->Node(SecInNode).GenContam +
-                 state.dataLoopNodes->Node(PriInNode).MassFlowRate * state.dataLoopNodes->Node(PriInNode).GenContam) /
-                state.dataLoopNodes->Node(MixedAirOutNode).MassFlowRate;
+            mixedAirOutNode.GenContam =
+                (secInNode.MassFlowRate * secInNode.GenContam + priInNode.MassFlowRate * priInNode.GenContam) / mixedAirOutNode.MassFlowRate;
         }
     }
 
     // update ADU flow data - because SimATMixer is called from the various zone equipment so the updates in SimZoneAirLoopEquipment won't work
-    int aduNum = state.dataSingleDuct->SysATMixer(SysNum).ADUNum;
-    state.dataDefineEquipment->AirDistUnit(aduNum).MassFlowRateTU = state.dataLoopNodes->Node(PriInNode).MassFlowRate;
-    state.dataDefineEquipment->AirDistUnit(aduNum).MassFlowRateZSup = state.dataLoopNodes->Node(PriInNode).MassFlowRate;
-    state.dataDefineEquipment->AirDistUnit(aduNum).MassFlowRateSup = state.dataLoopNodes->Node(PriInNode).MassFlowRate;
+    int aduNum = atMixer.ADUNum;
+    state.dataDefineEquipment->AirDistUnit(aduNum).MassFlowRateTU = priInNode.MassFlowRate;
+    state.dataDefineEquipment->AirDistUnit(aduNum).MassFlowRateZSup = priInNode.MassFlowRate;
+    state.dataDefineEquipment->AirDistUnit(aduNum).MassFlowRateSup = priInNode.MassFlowRate;
 }
 
 void GetATMixer(EnergyPlusData &state,
@@ -5780,7 +5874,9 @@ void SingleDuctAirTerminal::reportTerminalUnit(EnergyPlusData &state)
         if (minOASched != nullptr) schName = minOASched->Name;
     }
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermMinOAflowSch, adu.Name, schName);
-    OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name, this->ReheatComp);
+    // Should this be n/a for consistency?
+    OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermHeatCoilType, adu.Name,
+                                             (this->reheatCoilType == HVAC::CoilType::Invalid) ? "" : HVAC::coilTypeNames[(int)this->reheatCoilType]);
     OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermCoolCoilType, adu.Name, "n/a");
     if (this->fanType != HVAC::FanType::Invalid) {
         OutputReportPredefined::PreDefTableEntry(state, orp->pdchAirTermFanType, adu.Name, HVAC::fanTypeNames[(int)this->fanType]);
diff --git a/src/EnergyPlus/SingleDuct.hh b/src/EnergyPlus/SingleDuct.hh
index 9c74b910c17..f8272f86a65 100644
--- a/src/EnergyPlus/SingleDuct.hh
+++ b/src/EnergyPlus/SingleDuct.hh
@@ -91,16 +91,7 @@ namespace SingleDuct {
         SingleDuctCBVAVNoReheat,
         Num,
     };
-    enum class HeatingCoilType : int
-    {
-        Invalid = -1,
-        None,
-        Gas,
-        Electric,
-        SimpleHeating,
-        SteamAirHeating,
-        Num,
-    };
+
     enum class MinFlowFraction
     {
         Invalid = -1,
@@ -135,12 +126,14 @@ namespace SingleDuct {
         std::string SysName;                                // Name of the Sys
         std::string sysType;                                // Type of Sys ie. VAV, Mixing, Inducing, etc.
         SysType SysType_Num;                                // Numeric Equivalent for System type
+
         Sched::Schedule *availSched = nullptr;              // availability schedule
-        std::string ReheatComp;                             // Type of the Reheat Coil Object
-        HeatingCoilType ReheatComp_Num;                     // Numeric Equivalent in this module for Coil type
-        int ReheatComp_Index;                               // Returned Index number from other routines
-        std::string ReheatName;                             // name of reheat coil
-        DataPlant::PlantEquipmentType ReheatComp_PlantType; // typeOf_ number for plant type of heating coil
+
+      HVAC::CoilType reheatCoilType = HVAC::CoilType::Invalid; // Coil type
+        int ReheatCoilNum = 0;                               // Returned Index number from other routines
+        std::string ReheatCoilName;                             // name of reheat coil
+        DataPlant::PlantEquipmentType ReheatCoilPlantType = DataPlant::PlantEquipmentType::Invalid; // plant type of heating coil
+      
         HVAC::FanType fanType;                              // Numeric Equivalent in this module for fan type
         int Fan_Index;                                      // Returned Index number from other routines
         int ControlCompTypeNum;
@@ -220,8 +213,8 @@ namespace SingleDuct {
 
         // Default Constructor
         SingleDuctAirTerminal()
-            : SysNum(-1), SysType_Num(SysType::Invalid), ReheatComp_Num(HeatingCoilType::None), ReheatComp_Index(0),
-              ReheatComp_PlantType(DataPlant::PlantEquipmentType::Invalid), fanType(HVAC::FanType::Invalid), Fan_Index(0), ControlCompTypeNum(0),
+            : SysNum(-1), SysType_Num(SysType::Invalid), 
+              fanType(HVAC::FanType::Invalid), Fan_Index(0), ControlCompTypeNum(0),
               CompErrIndex(0), MaxAirVolFlowRate(0.0), AirMassFlowRateMax(0.0), MaxHeatAirVolFlowRate(0.0), HeatAirMassFlowRateMax(0.0),
               ZoneMinAirFracMethod(MinFlowFraction::Constant), ZoneMinAirFracDes(0.0), ZoneMinAirFrac(0.0), ZoneMinAirFracReport(0.0),
               ZoneFixedMinAir(0.0), ConstantMinAirFracSetByUser(false), FixedMinAirSetByUser(false), DesignMinAirFrac(0.0), DesignFixedMinAir(0.0),
@@ -376,17 +369,7 @@ struct SingleDuctData : BaseGlobalStruct
     int MaxNumsGSI = 0;   // Maximum number of numeric input fields
     int MaxAlphasGSI = 0; // Maximum number of alpha input fields
     int TotalArgsGSI = 0; // Total number of alpha and numeric arguments  = max for a
-    Real64 CoilInTempSS = 0.0;
-    Real64 DesCoilLoadSS = 0.0;
-    Real64 DesZoneHeatLoadSS = 0.0;
-    Real64 ZoneDesTempSS = 0.0;
-    Real64 ZoneDesHumRatSS = 0.0;
-    int CoilWaterInletNodeSS = 0;
-    int CoilWaterOutletNodeSS = 0;
-    int CoilSteamInletNodeSS = 0;
-    int CoilSteamOutletNodeSS = 0;
     Fluid::GlycolProps *water = nullptr;
-    Real64 UserInputMaxHeatAirVolFlowRateSS = 0.0; // user input for MaxHeatAirVolFlowRate
     Real64 MinAirMassFlowRevActSVAV = 0.0;         // minimum air mass flow rate used in "reverse action" air mass flow rate calculation
     Real64 MaxAirMassFlowRevActSVAV = 0.0;         // maximum air mass flow rate used in "reverse action" air mass flow rate calculation
     Real64 ZoneTempSCBVAV = 0.0;                   // zone air temperature [C]
diff --git a/src/EnergyPlus/StandardRatings.cc b/src/EnergyPlus/StandardRatings.cc
index e069159b7d7..ce29f5f49a1 100644
--- a/src/EnergyPlus/StandardRatings.cc
+++ b/src/EnergyPlus/StandardRatings.cc
@@ -883,8 +883,7 @@ namespace StandardRatings {
     void CalcDXCoilStandardRating(
         EnergyPlusData &state,
         std::string const &DXCoilName,                             // Name of DX coil for which HSPF is calculated
-        std::string const &DXCoilType,                             // Type of DX coil for which HSPF is calculated
-        int const DXCoilType_Num,                                  // Integer Type of DX coil - heating or cooling
+        HVAC::CoilType coilType,                                   // Integer Type of DX coil - heating or cooling
         int const ns,                                              // Number of compressor speeds
         Array1A<Real64> const RatedTotalCapacity,                  // Reference capacity of DX coil [W]
         Array1A<Real64> const RatedCOP,                            // Reference coefficient of performance [W/W]
@@ -1019,11 +1018,6 @@ namespace StandardRatings {
         // Using/Aliasing
         using Curve::CurveValue;
         using Curve::GetCurveMinMaxValues;
-        using HVAC::Coil_CoolingAirToAirVariableSpeed;
-        using HVAC::CoilDX_CoolingSingleSpeed;
-        using HVAC::CoilDX_HeatingEmpirical;
-        using HVAC::CoilDX_MultiSpeedCooling;
-        using HVAC::CoilDX_MultiSpeedHeating;
 
         // Argument array dimensioning
         RatedTotalCapacity.dim(ns);
@@ -1091,14 +1085,13 @@ namespace StandardRatings {
 
         NetCoolingCapRated = 0.0;
 
-        switch (DXCoilType_Num) {
+        switch (coilType) {
 
-        case CoilDX_CoolingSingleSpeed: { // Coil:Cooling:DX:SingleSpeed
+        case HVAC::CoilType::CoolingDXSingleSpeed: { // Coil:Cooling:DX:SingleSpeed
 
             CheckCurveLimitsForStandardRatings(state,
                                                DXCoilName,
-                                               DXCoilType,
-                                               DXCoilType_Num,
+                                               coilType,
                                                CapFTempCurveIndex(1),
                                                CapFFlowCurveIndex(1),
                                                EIRFTempCurveIndex(1),
@@ -1108,7 +1101,7 @@ namespace StandardRatings {
             // Calculated Net Cooling Capacity, SEER, SEER Default, EER, and IEER of single speed DX cooling coils
             std::map<std::string, Real64> StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(state,
                                                                                                          DXCoilName,
-                                                                                                         DXCoilType,
+                                                                                                         coilType,
                                                                                                          CapFTempCurveIndex(1),
                                                                                                          CapFFlowCurveIndex(1),
                                                                                                          EIRFTempCurveIndex(1),
@@ -1134,9 +1127,8 @@ namespace StandardRatings {
 
             // Writes the net rated cooling capacity, SEER, SEER Default, EER and IEER values to the EIO file and standard tabular output tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated(1),
                                SEER_User * ConvFromSIToIP,
                                SEER_Standard * ConvFromSIToIP,
@@ -1153,9 +1145,8 @@ namespace StandardRatings {
             // Writes the net rated cooling capacity, SEER2_USER, SEER2_Standard, EER and IEER values to the EIO file and standard tabular output
             // tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated_2023(1),
                                SEER2_User * ConvFromSIToIP,
                                SEER2_Standard * ConvFromSIToIP,
@@ -1171,7 +1162,7 @@ namespace StandardRatings {
             if (ASHRAE127StdRprt) {
                 DXCoolingCoilDataCenterStandardRatings(state,
                                                        DXCoilName,
-                                                       DXCoilType,
+                                                       coilType,
                                                        CapFTempCurveIndex(1),
                                                        CapFFlowCurveIndex(1),
                                                        EIRFTempCurveIndex(1),
@@ -1183,16 +1174,15 @@ namespace StandardRatings {
                                                        FanPowerPerEvapAirFlowRateFromInput(1),
                                                        NetTotCoolingCapRated,
                                                        TotElectricPowerRated);
-                ReportDXCoolCoilDataCenterApplication(state, DXCoilType, DXCoilName, DXCoilType_Num, NetTotCoolingCapRated, TotElectricPowerRated);
+                ReportDXCoolCoilDataCenterApplication(state, DXCoilName, coilType, NetTotCoolingCapRated, TotElectricPowerRated);
             }
             break;
         }
-        case CoilDX_HeatingEmpirical: { // Coil:Heating:DX:SingleSpeed
+        case HVAC::CoilType::HeatingDXSingleSpeed: { // Coil:Heating:DX:SingleSpeed
 
             CheckCurveLimitsForStandardRatings(state,
                                                DXCoilName,
-                                               DXCoilType,
-                                               DXCoilType_Num,
+                                               coilType,
                                                CapFTempCurveIndex(1),
                                                CapFFlowCurveIndex(1),
                                                EIRFTempCurveIndex(1),
@@ -1201,7 +1191,8 @@ namespace StandardRatings {
             // Calculate the standard ratings for single speed DX heating coil
             std::map<std::string, Real64> StandardRatingsResults =
                 SingleSpeedDXHeatingCoilStandardRatings(state,
-                                                        DXCoilType,
+                                                        DXCoilName,
+                                                        coilType,
                                                         RatedTotalCapacity(1),
                                                         RatedCOP(1),
                                                         CapFFlowCurveIndex(1),
@@ -1226,9 +1217,8 @@ namespace StandardRatings {
             IEER_2022 = StandardRatingsResults["IEER_2022"];
             // Writes the HSPF value to the EIO file and standard tabular output tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated(1),
                                SEER_User * ConvFromSIToIP,
                                SEER_Standard * ConvFromSIToIP,
@@ -1244,9 +1234,8 @@ namespace StandardRatings {
             // ANSI/AHRI 210/240 Std. 2023 Ratings
             // Writes the HSPF2 value to the EIO file and standard tabular output tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated_2023(1),
                                SEER2_User * ConvFromSIToIP,
                                SEER2_Standard * ConvFromSIToIP,
@@ -1260,13 +1249,13 @@ namespace StandardRatings {
                                true);
             break;
         }
-        case CoilDX_MultiSpeedCooling: { // Coil:Cooling:DX:MultiSpeed,
+          
+        case HVAC::CoilType::CoolingDXMultiSpeed: { // Coil:Cooling:DX:MultiSpeed,
 
             for (spnum = 1; spnum <= ns; ++spnum) {
                 CheckCurveLimitsForStandardRatings(state,
                                                    DXCoilName,
-                                                   DXCoilType,
-                                                   DXCoilType_Num,
+                                                   coilType,
                                                    CapFTempCurveIndex(spnum),
                                                    CapFFlowCurveIndex(spnum),
                                                    EIRFTempCurveIndex(spnum),
@@ -1275,8 +1264,8 @@ namespace StandardRatings {
             }
             // Calculate the standard ratings for multispeed DX cooling coil
             std::map<std::string, Real64> StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(state,
-                                                                                                         DXCoilType,
                                                                                                          DXCoilName,
+                                                                                                         coilType,
                                                                                                          CapFTempCurveIndex,
                                                                                                          CapFFlowCurveIndex,
                                                                                                          EIRFTempCurveIndex,
@@ -1304,9 +1293,8 @@ namespace StandardRatings {
 
             // Writes the SEER value to the EIO file and standard tabular output tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated(ns),
                                SEER_User * ConvFromSIToIP,
                                SEER_Standard * ConvFromSIToIP,
@@ -1321,9 +1309,8 @@ namespace StandardRatings {
 
             // Writes the SEER value to the EIO file and standard tabular output tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated_2023(ns),
                                SEER2_User * ConvFromSIToIP,
                                SEER2_Standard * ConvFromSIToIP,
@@ -1338,13 +1325,12 @@ namespace StandardRatings {
 
             break;
         }
-        case CoilDX_MultiSpeedHeating: { // Coil:Heating:DX:MultiSpeed
+        case HVAC::CoilType::HeatingDXMultiSpeed: { // Coil:Heating:DX:MultiSpeed
 
             for (spnum = 1; spnum <= ns; ++spnum) {
                 CheckCurveLimitsForStandardRatings(state,
                                                    DXCoilName,
-                                                   DXCoilType,
-                                                   DXCoilType_Num,
+                                                   coilType,
                                                    CapFTempCurveIndex(spnum),
                                                    CapFFlowCurveIndex(spnum),
                                                    EIRFTempCurveIndex(spnum),
@@ -1354,7 +1340,7 @@ namespace StandardRatings {
             // Calculate Net heating capacity and HSPF & HSPF2 of multispeed DX heating coils
             std::map<std::string, Real64> StandardRatingsResult = MultiSpeedDXHeatingCoilStandardRatings(state,
                                                                                                          DXCoilName,
-                                                                                                         DXCoilType,
+                                                                                                         coilType,
                                                                                                          CapFTempCurveIndex,
                                                                                                          CapFFlowCurveIndex,
                                                                                                          EIRFTempCurveIndex,
@@ -1384,9 +1370,8 @@ namespace StandardRatings {
             // ANSI/AHRI Std. 2017 Ratings
             // Writes the HSPF value to the EIO file and standard tabular output tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated(ns),
                                SEER_User * ConvFromSIToIP,
                                SEER_Standard * ConvFromSIToIP,
@@ -1402,9 +1387,8 @@ namespace StandardRatings {
             // ANSI/AHRI 210/240 Std. 2023 Ratings
             // Writes the HSPF2 value to the EIO file and standard tabular output tables
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated(ns),
                                SEER_User * ConvFromSIToIP,
                                SEER_Standard * ConvFromSIToIP,
@@ -1419,12 +1403,11 @@ namespace StandardRatings {
 
             break;
         }
-        case Coil_CoolingAirToAirVariableSpeed: {
+        case HVAC::CoilType::CoolingDXVariableSpeed: {
             for (spnum = 1; spnum <= ns; ++spnum) {
                 CheckCurveLimitsForStandardRatings(state,
                                                    DXCoilName,
-                                                   DXCoilType,
-                                                   DXCoilType_Num,
+                                                   coilType,
                                                    CapFTempCurveIndex(spnum),
                                                    CapFFlowCurveIndex(spnum),
                                                    EIRFTempCurveIndex(spnum),
@@ -1434,8 +1417,8 @@ namespace StandardRatings {
 
             // Calculate the standard ratings for multispeed DX cooling coil
             std::map<std::string, Real64> StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(state,
-                                                                                                            DXCoilType,
                                                                                                             DXCoilName,
+                                                                                                            coilType,
                                                                                                             CapFTempCurveIndex,
                                                                                                             CapFFlowCurveIndex,
                                                                                                             EIRFTempCurveIndex,
@@ -1463,9 +1446,8 @@ namespace StandardRatings {
 
             // Writes the SEER2 & IEER 2022 value to the EIO file and standard tabular output tables | 2023
             ReportDXCoilRating(state,
-                               DXCoilType,
                                DXCoilName,
-                               DXCoilType_Num,
+                               coilType,
                                NetCoolingCapRated_2023(ns),
                                SEER2_User * ConvFromSIToIP,
                                SEER2_Standard * ConvFromSIToIP,
@@ -1486,8 +1468,7 @@ namespace StandardRatings {
 
     void CalcTwoSpeedDXCoilRating(EnergyPlusData &state,
                                   std::string const &DXCoilName,
-                                  std::string const &DXCoilType,
-                                  int const DXCoilType_Num,
+                                  HVAC::CoilType const coilType,
                                   Array1A<Real64> const &RatedTotalCapacity,
                                   Real64 const RatedTotCap2,
                                   Array1A<Real64> const &RatedCOP,
@@ -1523,8 +1504,7 @@ namespace StandardRatings {
 
         StandardRatingsResult = TwoSpeedDXCoilStandardRatings(state,
                                                               DXCoilName,
-                                                              DXCoilType,
-                                                              DXCoilType_Num,
+                                                              coilType,
                                                               RatedTotalCapacity,
                                                               RatedTotCap2,
                                                               RatedCOP,
@@ -1564,9 +1544,8 @@ namespace StandardRatings {
 
         // Writes the SEER & IEER value to the EIO file and standard tabular output tables
         ReportDXCoilRating(state,
-                           DXCoilType,
                            DXCoilName,
-                           DXCoilType_Num,
+                           coilType,
                            NetCoolingCapRated,
                            SEER2_User * ConvFromSIToIP,
                            SEER2_Standard * ConvFromSIToIP,
@@ -1582,10 +1561,9 @@ namespace StandardRatings {
 
     std::map<std::string, Real64> TwoSpeedDXCoilStandardRatings(EnergyPlusData &state,
                                                                 std::string const &DXCoilName,
-                                                                std::string const &DXCoilType,
-                                                                int const &DXCoilType_Num,
+                                                                HVAC::CoilType const coilType,
                                                                 Array1A<Real64> const &RatedTotalCapacity,
-                                                                Real64 const &RatedTotCap2,
+                                                                Real64 const &RatedTotCap2, // What is the point of passing a scalar by const &?
                                                                 Array1A<Real64> const &RatedCOP,
                                                                 Real64 const &RatedCOP2,
                                                                 Array1A_int const &CapFFlowCurveIndex, // only hs
@@ -1646,8 +1624,7 @@ namespace StandardRatings {
             // TODO:BPS Implement Two Speed Case :
             CheckCurveLimitsForStandardRatings(state,
                                                DXCoilName,
-                                               DXCoilType,
-                                               DXCoilType_Num,
+                                               coilType,
                                                TSCCapFTemp(spnum),
                                                CapFFlowCurveIndex(1), // only HS
                                                TSEIRFTemp(spnum),
@@ -1688,7 +1665,7 @@ namespace StandardRatings {
 
             // Calculate the IEER 2022 Standard ratings for Two Speed DX cooling coil | AHRI 340/360
             std::tie(IEER_2022, NetCoolingCapRated2022, EER_2022) = IEERCalculationTwoSpeed(state,
-                                                                                            DXCoilType,
+                                                                                            coilType,
                                                                                             CondenserType,
                                                                                             TSCCapFTemp,
                                                                                             TSRatedTotCap,
@@ -1975,7 +1952,8 @@ namespace StandardRatings {
 
     std::map<std::string, Real64> SingleSpeedDXHeatingCoilStandardRatings(
         EnergyPlusData &state,
-        [[maybe_unused]] std::string const &DXCoilType,            // Type of DX coil for which HSPF is calculated
+        std::string const &coilName,
+        HVAC::CoilType coilType,
         Real64 const RatedTotalCapacity,                           // Reference capacity of DX coil [W]
         Real64 const RatedCOP,                                     // Reference coefficient of performance [W/W]
         int const CapFFlowCurveIndex,                              // Index for the capacity as a function of flow fraction modifier curve
@@ -2424,8 +2402,8 @@ namespace StandardRatings {
     }
 
     std::tuple<Real64, Real64, Real64, Real64> SEER2CalulcationCurveFit(EnergyPlusData &state,
-                                                                        [[maybe_unused]] std::string const &CoilType,
-                                                                        EnergyPlus::CoilCoolingDXCurveFitOperatingMode operatingMode)
+                                                                        HVAC::CoilType coilType,
+                                                                        CoilCoolingDXCurveFitOperatingMode operatingMode)
     {
         Real64 EEER2(0.0);
         Real64 SEER2_User(0.0);
@@ -2480,7 +2458,7 @@ namespace StandardRatings {
     }
 
     std::tuple<Real64, Real64, Real64>
-    IEERCalulcationCurveFit(EnergyPlusData &state, std::string const &CoilType, EnergyPlus::CoilCoolingDXCurveFitOperatingMode operatingMode)
+    IEERCalulcationCurveFit(EnergyPlusData &state, HVAC::CoilType coilType, EnergyPlus::CoilCoolingDXCurveFitOperatingMode operatingMode)
     {
         Real64 IEER_2022(0.0);
         Real64 EER_2022(0.0);
@@ -2526,7 +2504,7 @@ namespace StandardRatings {
         }
 
         std::tie(IEER_2022, NetCoolingCapRated2022, EER_2022) = IEERCalculationVariableSpeed(state,
-                                                                                             CoilType,
+                                                                                             coilType,
                                                                                              nsp,
                                                                                              MSCCapFTemp,
                                                                                              MSRatedTotCap,
@@ -2543,7 +2521,7 @@ namespace StandardRatings {
 
     std::tuple<Real64, Real64, Real64> IEERCalculationVariableSpeed(
         EnergyPlusData &state,
-        std::string const &VSCoilType, // Type of DX coil
+        HVAC::CoilType coilType,
         int const nsp,
         Array1A_int const &CapFTempCurveIndex,
         Array1A<Real64> const &RatedTotalCapacity,
@@ -2594,7 +2572,7 @@ namespace StandardRatings {
             // if CondenserType is AirCooled
             if (CondenserType(spnum) == DataHeatBalance::RefrigCondenserType::Air) {
                 // Cooling Coil | Calculate the net cooling capacity at the rated conditions (23.89C(75F) Wet Bulb and 35.0C(95F) Dry Bulb )
-                if (VSCoilType.find("Cooling") != std::string::npos)
+                if (HVAC::coilTypeIsCooling[(int)coilType])
                     TotCapTempModFac(spnum) =
                         Curve::CurveValue(state, CapFTempCurveIndex(spnum), CoolingCoilInletAirWetBulbTempRated, CoilInletAirCoolDryBulbIEER);
                 else // Heating Coil | Calculate the net cooling capacity at the rated conditions (6.11C(43F) Wet Bulb and 8.33C(47F) Dry Bulb )
@@ -2875,7 +2853,7 @@ namespace StandardRatings {
             // 2, 3 & 4 Speeds
             Real64 QAFull_(0.0);
             std::tie(IEER_2022, QAFull_, EER_2022) = IEERCalculationMultiSpeed(state,
-                                                                               VSCoilType,
+                                                                               coilType,
                                                                                nsp,
                                                                                CapFTempCurveIndex,
                                                                                RatedTotalCapacity,
@@ -2890,7 +2868,7 @@ namespace StandardRatings {
             // 1 Speed
             Real64 QAFull_(0.0);
             std::tie(IEER_2022, QAFull_, EER_2022) = IEERCalculationSingleSpeed(state,
-                                                                                VSCoilType,
+                                                                                coilType,
                                                                                 CapFTempCurveIndex(1),
                                                                                 RatedTotalCapacity(1),
                                                                                 TotCapFlowModFac(1),
@@ -2907,7 +2885,7 @@ namespace StandardRatings {
 
     std::tuple<Real64, Real64, Real64> IEERCalculationMultiSpeed(
         EnergyPlus::EnergyPlusData &state,
-        std::string const &DXCoilType, // Type of DX coil
+        HVAC::CoilType coilType, // Type of DX coil
         int const nsp,
         Array1A_int const &CapFTempCurveIndex,
         Array1A<Real64> const &RatedTotalCapacity,
@@ -2958,7 +2936,7 @@ namespace StandardRatings {
             // if CondenserType is AirCooled
             if (CondenserType(spnum) == DataHeatBalance::RefrigCondenserType::Air) {
                 // Cooling Coil | Calculate the net cooling capacity at the rated conditions (23.89C(75F) Wet Bulb and 35.0C(95F) Dry Bulb )
-                if (DXCoilType.find("Cooling") != std::string::npos)
+                if (HVAC::coilTypeIsCooling[(int)coilType])
                     TotCapTempModFac(spnum) =
                         Curve::CurveValue(state, CapFTempCurveIndex(spnum), CoolingCoilInletAirWetBulbTempRated, CoilInletAirCoolDryBulbIEER);
                 else // Heating Coil | Calculate the net cooling capacity at the rated conditions (6.11C(43F) Wet Bulb and 8.33C(47F) Dry Bulb )
@@ -3167,7 +3145,7 @@ namespace StandardRatings {
             std::reverse_copy(RatedTotalCapacity.begin(), RatedTotalCapacity.end(), RatedTotalCapacityHighAndLow.begin());
 
             std::tie(IEER_2022, QAFull_, EER_2022) = IEERCalculationTwoSpeed(state,
-                                                                             DXCoilType,
+                                                                             coilType,
                                                                              CondenserType,
                                                                              CapFTempCurveIndex,
                                                                              RatedTotalCapacityHighAndLow,
@@ -3186,7 +3164,7 @@ namespace StandardRatings {
 
     std::tuple<Real64, Real64, Real64> IEERCalculationTwoSpeed(
         EnergyPlusData &state,
-        std::string const &DXCoilType, // Type of DX coil
+        HVAC::CoilType coilType,
         Array1D<DataHeatBalance::RefrigCondenserType> const &CondenserType,
         Array1A_int const &CapFTempCurveIndex,
         Array1A<Real64> const &RatedTotalCapacity,
@@ -3245,7 +3223,7 @@ namespace StandardRatings {
         for (int spnum = nsp; spnum > 0; --spnum) {
 
             if (spnum == 3 || spnum == 4) {
-                if (DXCoilType == "Coil:Cooling:DX:TwoSpeed") {
+              if (coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                     TotCapFlowModFac(spnum) = Curve::CurveValue(state, CCapFFlowCurveIndex(1), AirMassFlowRatioRated);
                     EIRFlowModFac(spnum) = Curve::CurveValue(state, EIRFFlowCurveIndex(1), AirMassFlowRatioRated);
                 } else {
@@ -3254,7 +3232,7 @@ namespace StandardRatings {
                     EIRFlowModFac(spnum) = Curve::CurveValue(state, EIRFFlowCurveIndex(2), AirMassFlowRatioRated);
                 }
             } else if (spnum == 1 || spnum == 2) {
-                if (DXCoilType == "Coil:Cooling:DX:TwoSpeed") {
+                if (coilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                     TotCapFlowModFac(spnum) = 1; // As per IO Reference there are no CCapFFlowCurve for Low Speed | Section ??
                     EIRFlowModFac(spnum) = 1;    // As per IO Reference there are no EIRFFlowCurve for Low Speed | Section ??
                 } else {
@@ -3267,7 +3245,7 @@ namespace StandardRatings {
             if (_condenserType(spnum) == DataHeatBalance::RefrigCondenserType::Air) { // Case: CondenserType is AirCooled
                 if (spnum == 3 || spnum == 4) {
                     // Cooling Coil | Calculate the net cooling capacity at the rated conditions (23.89C(75F) Wet Bulb and 35.0C(95F) Dry Bulb )
-                    if (DXCoilType.find("Cooling") != std::string::npos)
+                    if (HVAC::coilTypeIsCooling[(int)coilType])
                         TotCapTempModFac(spnum) =
                             Curve::CurveValue(state, CapFTempCurveIndex(1), CoolingCoilInletAirWetBulbTempRated, CoilInletAirCoolDryBulbIEER);
                     else // Heating Coil | Calculate the net cooling capacity at the rated conditions (6.11C(43F) Wet Bulb and 8.33C(47F) Dry Bulb )
@@ -3275,7 +3253,7 @@ namespace StandardRatings {
                             Curve::CurveValue(state, CapFTempCurveIndex(1), CoilHeatingInletAirWetBulbTempIEER, CoilHeatingInletAirCoolDryBulbIEER);
                 } else if (spnum == 1 || spnum == 2) {
                     // Cooling Coil | Calculate the net cooling capacity at the rated conditions (23.89C(75F) Wet Bulb and 35.0C(95F) Dry Bulb )
-                    if (DXCoilType.find("Cooling") != std::string::npos)
+                    if (HVAC::coilTypeIsCooling[(int)coilType])
                         TotCapTempModFac(spnum) =
                             Curve::CurveValue(state, CapFTempCurveIndex(2), CoolingCoilInletAirWetBulbTempRated, CoilInletAirCoolDryBulbIEER);
                     else // Heating Coil | Calculate the net cooling capacity at the rated conditions (6.11C(43F) Wet Bulb and 8.33C(47F) Dry Bulb )
@@ -3367,7 +3345,7 @@ namespace StandardRatings {
     }
 
     std::tuple<Real64, Real64, Real64> IEERCalculationSingleSpeed(EnergyPlus::EnergyPlusData &state,
-                                                                  std::string const &DXCoilType, // Type of DX coil for which HSPF is calculated
+                                                                  HVAC::CoilType coilType,
                                                                   const int CapFTempCurveIndex,
                                                                   const Real64 RatedTotalCapacity,
                                                                   const Real64 TotCapFlowModFac,
@@ -3397,7 +3375,7 @@ namespace StandardRatings {
         // if CondenserType is AirCooled
         if (CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
             // Calculate the net cooling capacity at the rated conditions (19.44C(67F) Wet Bulb and 35.0C(95F) Dry Bulb )
-            if (DXCoilType.find("Cooling") != std::string::npos)
+            if (HVAC::coilTypeIsCooling[(int)coilType])
                 TotCapTempModFac = Curve::CurveValue(state, CapFTempCurveIndex, CoilInletAirWetBulbTemp, CoilInletAirCoolDryBulbIEER);
             else
                 TotCapTempModFac =
@@ -3559,7 +3537,7 @@ namespace StandardRatings {
     std::map<std::string, Real64> SingleSpeedDXCoolingCoilStandardRatings(
         EnergyPlusData &state,
         std::string const &DXCoilName,                         // Name of DX coil for which HSPF is calculated
-        std::string const &DXCoilType,                         // Type of DX coil - heating or cooling
+        HVAC::CoilType coilType,
         int const CapFTempCurveIndex,                          // Index for the capacity as a function of temperature modifier curve
         int const CapFFlowCurveIndex,                          // Index for the capacity as a function of flow fraction modifier curve
         int const EIRFTempCurveIndex,                          // Index for the EIR as a function of temperature modifier curve
@@ -3735,10 +3713,10 @@ namespace StandardRatings {
             StandarRatingResults["NetCoolingCapRated"] = NetCoolingCapRated;
 
             // IEER 2022 Calculations
-            if (DXCoilType == "Coil:Cooling:DX:SingleSpeed") {
+            if (coilType == HVAC::CoilType::CoolingDXSingleSpeed) {
 
                 std::tie(IEER_2022, NetCoolingCapRated2023, EER_2022) = IEERCalculationSingleSpeed(state,
-                                                                                                   DXCoilType,
+                                                                                                   coilType,
                                                                                                    CapFTempCurveIndex,
                                                                                                    RatedTotalCapacity,
                                                                                                    TotCapFlowModFac,
@@ -3757,7 +3735,7 @@ namespace StandardRatings {
             ShowSevereError(state,
                             format("Standard Ratings: {} {} has esither zero rated total cooling capacity or zero rated air volume flow rate. "
                                    "Standard ratings cannot be calculated.",
-                                   DXCoilType,
+                                   HVAC::coilTypeNames[(int)coilType],
                                    DXCoilName));
         }
         return StandarRatingResults;
@@ -3766,7 +3744,7 @@ namespace StandardRatings {
     void DXCoolingCoilDataCenterStandardRatings(
         EnergyPlusData &state,
         std::string const &DXCoilName,                    // Name of DX coil for which HSPF is calculated
-        std::string const &DXCoilType,                    // Type of DX coil - heating or cooling
+        HVAC::CoilType coilType,
         int const CapFTempCurveIndex,                     // Index for the capacity as a function of temperature modifier curve
         int const CapFFlowCurveIndex,                     // Index for the capacity as a function of flow fraction modifier curve
         int const EIRFTempCurveIndex,                     // Index for the EIR as a function of temperature modifier curve
@@ -3863,7 +3841,7 @@ namespace StandardRatings {
         } else {
             ShowSevereError(state,
                             format("Standard Ratings: {} {} has zero rated total cooling capacity. Capacity and Power cannot be calculated.",
-                                   DXCoilType,
+                                   HVAC::coilTypeNames[(int)coilType],
                                    DXCoilName));
         }
     }
@@ -5307,8 +5285,8 @@ namespace StandardRatings {
 
     std::map<std::string, Real64> MultiSpeedDXCoolingCoilStandardRatings(
         EnergyPlusData &state,
-        std::string const &DXCoilType,                                  // Type of DX coil for which HSPF is calculated
         std::string const &DXCoilName,                                  // Type of DX coil for which standard Ratings are calculated
+        HVAC::CoilType coilType,
         Array1A_int const CapFTempCurveIndex,                           // Index for the capacity as a function of temperature modifier curve
         Array1A_int const CapFFlowCurveIndex,                           // Index for the capacity as a function of flow fraction modifier curve
         Array1A_int const EIRFTempCurveIndex,                           // Index for the EIR as a function of temperature modifier curve
@@ -5446,7 +5424,7 @@ namespace StandardRatings {
             // Gross total cooling capacity is greater than 65,000 Btu/h (19049.61955 Watts)
             // Section 2.1 (ANSI/AHRI 210-240 2023)
             std::tie(IEER_2022, NetCoolingCapRated2023, EER_2022) = IEERCalculationMultiSpeed(state,
-                                                                                              DXCoilType,
+                                                                                              coilType,
                                                                                               nsp,
                                                                                               CapFTempCurveIndex,
                                                                                               RatedTotalCapacity,
@@ -5484,8 +5462,8 @@ namespace StandardRatings {
 
     std::map<std::string, Real64> VariableSpeedDXCoolingCoilStandardRatings(
         EnergyPlusData &state,
-        std::string const &DXCoilType,                                  // Type of DX coil for which HSPF is calculated
         std::string const &DXCoilName,                                  // Name of the DX Coil for which Standard Ratings are calculated.
+        HVAC::CoilType coilType,
         Array1A_int const CapFTempCurveIndex,                           // Index for the capacity as a function of temperature modifier curve
         Array1A_int const CapFFlowCurveIndex,                           // Index for the capacity as a function of flow fraction modifier curve
         Array1A_int const EIRFTempCurveIndex,                           // Index for the EIR as a function of temperature modifier curve
@@ -5625,7 +5603,7 @@ namespace StandardRatings {
             // IEER Calculation 2022
             std::tie(IEER_2022, NetCoolingCapRatedMaxSpeed2023, EER_2022) =
                 IEERCalculationVariableSpeed(state,
-                                             DXCoilType,
+                                             coilType,
                                              nsp,
                                              CapFTempCurveIndex,
                                              GrossRatedCapacityAtSpeedLevel, // RatedTotalCapacity,
@@ -5640,8 +5618,7 @@ namespace StandardRatings {
 
         } else {
             ShowSevereError(state,
-                            "Standard Ratings: Coil:Cooling:DX " + DXCoilType + // TODO: Use dynamic COIL TYPE and COIL INSTANCE name later
-                                " has zero rated total cooling capacity. Standard ratings cannot be calculated.");
+                            format("Standard Ratings: Coil:Cooling:DX {} has zero rated total cooling capacity. Standard ratings cannot be calculated.", DXCoilName));
         }
 
         // From SEER2 implementation
@@ -6551,7 +6528,7 @@ namespace StandardRatings {
     std::map<std::string, Real64> MultiSpeedDXHeatingCoilStandardRatings(
         EnergyPlusData &state,
         [[maybe_unused]] std::string const &DXCoilName,               // Name of DX coil for which HSPF is calculated
-        [[maybe_unused]] std::string const &DXCoilType,               // Type of DX coil for which HSPF is calculated
+        [[maybe_unused]] HVAC::CoilType coilType,               // Type of DX coil for which HSPF is calculated
         Array1A_int const CapFTempCurveIndex,                         // Index for the capacity as a function of temperature modifier curve
         Array1A_int const CapFFlowCurveIndex,                         // Index for the capacity as a function of flow fraction modifier curve
         Array1A_int const EIRFTempCurveIndex,                         // Index for the EIR as a function of temperature modifier curve
@@ -6682,9 +6659,8 @@ namespace StandardRatings {
     }
 
     void ReportDXCoilRating(EnergyPlusData &state,
-                            std::string const &CompType,    // Type of component
-                            std::string_view CompName,      // Name of component
-                            int const CompTypeNum,          // TypeNum of component
+                            std::string const &CompName,      // Name of component
+                            HVAC::CoilType coilType,
                             Real64 const CoolCapVal,        // Standard total (net) cooling capacity for AHRI Std. 210/240 {W}
                             Real64 const SEERUserIP,        // SEER value in IP units from user PLR curve {Btu/W-h}
                             Real64 const SEERStandardIP,    // SEER value in IP units from AHRI Std 210/240-2008 default PLF curve and C_D {Btu/W-h}
@@ -6718,13 +6694,6 @@ namespace StandardRatings {
         // Using/Aliasing
 
         using namespace OutputReportPredefined;
-        using HVAC::Coil_CoolingAirToAirVariableSpeed;
-        using HVAC::CoilDX_CoolingSingleSpeed;
-        using HVAC::CoilDX_CoolingTwoSpeed;
-        using HVAC::CoilDX_HeatingEmpirical;
-        using HVAC::CoilDX_MultiSpeedCooling;
-        using HVAC::CoilDX_MultiSpeedHeating;
-
         // Locals
         // SUBROUTINE ARGUMENT DEFINITIONS:
         //   or ANSI/AHRI Std. 340/360 {W}
@@ -6742,9 +6711,9 @@ namespace StandardRatings {
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
 
-        switch (CompTypeNum) {
+        switch (coilType) {
 
-        case CoilDX_CoolingSingleSpeed: {
+        case HVAC::CoilType::CoolingDXSingleSpeed: {
             if (!AHRI2023StandardRatings) {
                 if (state.dataHVACGlobal->StandardRatingsMyCoolOneTimeFlag) {
                     static constexpr std::string_view Format_994(
@@ -6758,9 +6727,9 @@ namespace StandardRatings {
 
                 static constexpr std::string_view Format_991(
                     " DX Cooling Coil Standard Rating Information, {}, {}, {:.1R}, {:.2R}, {:.2R}, {:.2R}, {:.2R}, {:.1R}\n");
-                print(state.files.eio, Format_991, CompType, CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
+                print(state.files.eio, Format_991, HVAC::coilTypeNames[(int)coilType], CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
 
-                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType, CompName, CompType);
+                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType, CompName, HVAC::coilTypeNames[(int)coilType]);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilNetCapSI, CompName, CoolCapVal, 1);
                 // W/W is the same as Btuh/Btuh so that's fine too
                 if (EERValueSI > 0.0) {
@@ -6805,9 +6774,9 @@ namespace StandardRatings {
 
                 static constexpr std::string_view Format_991_(
                     " DX Cooling Coil AHRI 2023 Standard Rating Information, {}, {}, {:.1R}, {:.2R}, {:.2R}, {:.2R}, {:.2R}, {:.1R}\n");
-                print(state.files.eio, Format_991_, CompType, CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
+                print(state.files.eio, Format_991_, HVAC::coilTypeNames[(int)coilType], CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
 
-                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType_2023, CompName, CompType);
+                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType_2023, CompName, HVAC::coilTypeNames[(int)coilType]);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilNetCapSI_2023, CompName, CoolCapVal, 1);
                 // W/W is the same as Btuh/Btuh so that's fine too
                 if (EERValueSI > 0.0) {
@@ -6840,8 +6809,9 @@ namespace StandardRatings {
             }
             break;
         }
-        case CoilDX_HeatingEmpirical:
-        case CoilDX_MultiSpeedHeating: {
+
+        case HVAC::CoilType::HeatingDXSingleSpeed:
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
             if (!AHRI2023StandardRatings) {
                 if (state.dataHVACGlobal->StandardRatingsMyHeatOneTimeFlag) {
                     static constexpr std::string_view Format_992(
@@ -6853,9 +6823,9 @@ namespace StandardRatings {
                 }
 
                 static constexpr std::string_view Format_993(" DX Heating Coil Standard Rating Information, {}, {}, {:.1R}, {:.1R}, {:.2R}, {}\n");
-                print(state.files.eio, Format_993, CompType, CompName, HighHeatingCapVal, LowHeatingCapVal, HSPFValueIP, RegionNum);
+                print(state.files.eio, Format_993, HVAC::coilTypeNames[(int)coilType], CompName, HighHeatingCapVal, LowHeatingCapVal, HSPFValueIP, RegionNum);
 
-                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilType, CompName, CompType);
+                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilType, CompName, HVAC::coilTypeNames[(int)coilType]);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilHighCap, CompName, HighHeatingCapVal, 1);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilLowCap, CompName, LowHeatingCapVal, 1);
                 // Btu/W-h will convert to itself
@@ -6876,9 +6846,9 @@ namespace StandardRatings {
 
                 static constexpr std::string_view Format_993_(
                     " DX Heating Coil AHRI 2023 Standard Rating Information, {}, {}, {:.1R}, {:.1R}, {:.2R}, {}\n");
-                print(state.files.eio, Format_993_, CompType, CompName, HighHeatingCapVal, LowHeatingCapVal, HSPFValueIP, RegionNum);
+                print(state.files.eio, Format_993_, HVAC::coilTypeNames[(int)coilType], CompName, HighHeatingCapVal, LowHeatingCapVal, HSPFValueIP, RegionNum);
 
-                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilType_2023, CompName, CompType);
+                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilType_2023, CompName, HVAC::coilTypeNames[(int)coilType]);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilHighCap_2023, CompName, HighHeatingCapVal, 1);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXHeatCoilLowCap_2023, CompName, LowHeatingCapVal, 1);
                 // Btu/W-h will convert to itself
@@ -6890,9 +6860,10 @@ namespace StandardRatings {
             }
             break;
         }
-        case CoilDX_CoolingTwoSpeed:
-        case Coil_CoolingAirToAirVariableSpeed:
-        case CoilDX_MultiSpeedCooling: {
+
+        case HVAC::CoilType::CoolingDXTwoSpeed:
+        case HVAC::CoilType::CoolingDXVariableSpeed:
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             if (!AHRI2023StandardRatings) {
                 if (state.dataHVACGlobal->StandardRatingsMyCoolOneTimeFlag) {
                     static constexpr std::string_view Format_994(
@@ -6906,9 +6877,9 @@ namespace StandardRatings {
 
                 static constexpr std::string_view Format_995(
                     " DX Cooling Coil Standard Rating Information, {}, {}, {:.1R}, {:.2R}, {:.2R}, {:.2R}, {:.2R}, {}\n");
-                print(state.files.eio, Format_995, CompType, CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
+                print(state.files.eio, Format_995, HVAC::coilTypeNames[(int)coilType], CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
 
-                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType, CompName, CompType);
+                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType, CompName, HVAC::coilTypeNames[(int)coilType]);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilNetCapSI, CompName, CoolCapVal, 1);
                 if (EERValueSI > 0.0) {
                     PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilCOP, CompName, EERValueSI, 2);
@@ -6951,8 +6922,8 @@ namespace StandardRatings {
 
                 static constexpr std::string_view Format_995_(
                     " DX Cooling Coil AHRI 2023 Standard Rating Information, {}, {}, {:.1R}, {:.2R}, {:.2R}, {:.2R}, {:.2R}, {:.1R}\n");
-                print(state.files.eio, Format_995_, CompType, CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
-                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType_2023, CompName, CompType);
+                print(state.files.eio, Format_995_, HVAC::coilTypeNames[(int)coilType], CompName, CoolCapVal, EERValueSI, EERValueIP, SEERUserIP, SEERStandardIP, IEERValueIP);
+                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType_2023, CompName, HVAC::coilTypeNames[(int)coilType]);
                 PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilNetCapSI_2023, CompName, CoolCapVal, 1);
                 // W/W is the same as Btuh/Btuh so that's fine too
                 if (EERValueSI > 0.0) {
@@ -6992,9 +6963,8 @@ namespace StandardRatings {
     }
 
     void ReportDXCoolCoilDataCenterApplication(EnergyPlusData &state,
-                                               std::string const &CompType,           // Type of component
-                                               std::string_view CompName,             // Name of component
-                                               int const CompTypeNum,                 // TypeNum of component
+                                               std::string const &CompName,             // Name of component
+                                               HVAC::CoilType const coilType,                 // TypeNum of component
                                                Array1D<Real64> &NetCoolingCapRated,   // net cooling capacity of single speed DX cooling coil
                                                Array1D<Real64> &TotElectricPowerRated // total electric power including supply fan
     )
@@ -7022,9 +6992,8 @@ namespace StandardRatings {
         // Using/Aliasing
 
         using namespace OutputReportPredefined;
-        using HVAC::CoilDX_CoolingSingleSpeed;
 
-        if (CompTypeNum == CoilDX_CoolingSingleSpeed) {
+        if (coilType == HVAC::CoilType::CoolingDXSingleSpeed) {
             if (state.dataHVACGlobal->StandardRatingsMyCoolOneTimeFlag3) {
                 static constexpr std::string_view Format_101(
                     "! <DX Cooling Coil ASHRAE 127 Standard Ratings Information>, Component Type, Component Name, Standard 127 "
@@ -7044,7 +7013,7 @@ namespace StandardRatings {
                     "{:.1R}, {:.1R}, {:.1R}, {:.1R}, {:.1R}\n");
                 print(state.files.eio,
                       Format_102,
-                      CompType,
+                      HVAC::coilTypeNames[(int)coilType],
                       CompName,
                       ClassName,
                       NetCoolingCapRated(Num + 1),
@@ -7055,7 +7024,7 @@ namespace StandardRatings {
                       TotElectricPowerRated(Num + 3),
                       NetCoolingCapRated(Num + 4),
                       TotElectricPowerRated(Num + 4));
-                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType2, CompNameNew, CompType);
+                PreDefTableEntry(state, state.dataOutRptPredefined->pdchDXCoolCoilType2, CompNameNew, HVAC::coilTypeNames[(int)coilType]);
                 // Note: If you call format("{:.1R}", NetCoolingCapRated(Num + 1)),
                 // Then it's not the OutputReportPredefined::PreDefTableEntry prototype with Real64 that is called.
                 // As a result, the entry isn't marked as being Real (origEntryIsReal) and unit conversion does not occur
@@ -7080,8 +7049,7 @@ namespace StandardRatings {
 
     void CheckCurveLimitsForStandardRatings(EnergyPlusData &state,
                                             std::string const &DXCoilName, // Name of DX coil for which HSPF is calculated
-                                            std::string const &DXCoilType, // Type of DX coil - heating or cooling
-                                            int const DXCoilTypeNum,       // Integer type of DX coil - heating or cooling
+                                            HVAC::CoilType coilType,       // Integer type of DX coil - heating or cooling
                                             int const CapFTempCurveIndex,  // Index for the capacity as a function of temperature modifier curve
                                             int const CapFFlowCurveIndex,  // Index for the capacity as a function of flow fraction modifier curve
                                             int const EIRFTempCurveIndex,  // Index for the EIR as a function of temperature modifier curve
@@ -7111,10 +7079,6 @@ namespace StandardRatings {
         using Curve::GetCurveIndex;
         using Curve::GetCurveMinMaxValues;
         using Curve::GetCurveName;
-        using HVAC::CoilDX_CoolingSingleSpeed;
-        using HVAC::CoilDX_HeatingEmpirical;
-        using HVAC::CoilDX_MultiSpeedCooling;
-        using HVAC::CoilDX_MultiSpeedHeating;
 
         // Locals
         // SUBROUTINE ARGUMENT DEFINITIONS:
@@ -7177,9 +7141,9 @@ namespace StandardRatings {
         bool HeatingEIRCurveHSPFLimitsExceeded(false); // Logical for EIR curve temperature limits being exceeded
         // (HSPF calcs)
 
-        switch (DXCoilTypeNum) {
+        switch (coilType) {
 
-        case CoilDX_CoolingSingleSpeed: {
+        case HVAC::CoilType::CoolingDXSingleSpeed: {
             bool CapCurveMidOATLimitsExceeded = false; // Logical for capacity curve temperature limits being exceeded (mid temp)
             bool EIRCurveMidOATLimitsExceeded = false; // Logical for EIR curve temperature limits being exceeded (mid temp)
             bool PLFfPLRforSEERLimitsExceeded = false; // Logical for PLF function of PLR limits being exceeded
@@ -7242,7 +7206,7 @@ namespace StandardRatings {
                 ShowWarningError(
                     state,
                     format("The Standard Ratings is calculated for {} = {} but not at the AHRI test condition due to curve out of bound.",
-                           DXCoilType,
+                           HVAC::coilTypeNames[(int)coilType],
                            DXCoilName));
                 ShowContinueError(state,
                                   " Review the Standard Ratings calculations in the Engineering Reference for this coil type. Also, use "
@@ -7259,7 +7223,7 @@ namespace StandardRatings {
                     if (state.dataGlobal->DisplayExtraWarnings) {
                         ShowContinueError(
                             state,
-                            format("{}={}:  Standard Rating Cooling Capacity calculated is not at the AHRI test condition.", DXCoilType, DXCoilName));
+                            format("{}={}:  Standard Rating Cooling Capacity calculated is not at the AHRI test condition.", HVAC::coilTypeNames[(int)coilType], DXCoilName));
                         if (CapCurveHighOATLimitsExceeded) {
                             ShowContinueError(
                                 state,
@@ -7282,7 +7246,7 @@ namespace StandardRatings {
                     if (state.dataGlobal->DisplayExtraWarnings) {
                         ShowContinueError(
                             state,
-                            format("{}={}:  Energy Efficiency Ratio (EER) calculated is not at the AHRI test condition.", DXCoilType, DXCoilName));
+                            format("{}={}:  Energy Efficiency Ratio (EER) calculated is not at the AHRI test condition.", HVAC::coilTypeNames[(int)coilType], DXCoilName));
                         if (CapCurveHighOATLimitsExceeded) {
                             ShowContinueError(
                                 state,
@@ -7320,7 +7284,7 @@ namespace StandardRatings {
                     if (state.dataGlobal->DisplayExtraWarnings) {
                         ShowContinueError(state,
                                           format("{}={}:  Seasonal Energy Efficiency Ratio (SEER) calculated is not at the AHRI test condition.",
-                                                 DXCoilType,
+                                                 HVAC::coilTypeNames[(int)coilType],
                                                  DXCoilName));
                         if (CapCurveMidOATLimitsExceeded) {
                             ShowContinueError(
@@ -7365,7 +7329,7 @@ namespace StandardRatings {
                     if (state.dataGlobal->DisplayExtraWarnings) {
                         ShowContinueError(state,
                                           format("{}={}:  Integrated Energy Efficiency Ratio (IEER) calculated is not at the AHRI test condition.",
-                                                 DXCoilType,
+                                                 HVAC::coilTypeNames[(int)coilType],
                                                  DXCoilName));
                         if (CapCurveIEERLimitsExceeded) {
                             ShowContinueError(
@@ -7401,7 +7365,7 @@ namespace StandardRatings {
             } // End of curve error messages
             break;
         }
-        case CoilDX_HeatingEmpirical: {
+        case HVAC::CoilType::HeatingDXSingleSpeed: {
             {
                 if (state.dataCurveManager->curves(CapFTempCurveIndex)->numDims == 1) {
                     GetCurveMinMaxValues(state, CapFTempCurveIndex, HeatingCapODBTempMin, HeatingCapODBTempMax);
@@ -7448,7 +7412,7 @@ namespace StandardRatings {
                 ShowWarningError(
                     state,
                     format("The Standard Ratings is calculated for {} = {} but not at the AHRI test condition due to curve out of bound.",
-                           DXCoilType,
+                           HVAC::coilTypeNames[(int)coilType],
                            DXCoilName));
                 ShowContinueError(state,
                                   " Review the Standard Ratings calculations in the Engineering Reference for this coil type. Also, use "
@@ -7461,7 +7425,7 @@ namespace StandardRatings {
                 if (state.dataGlobal->DisplayExtraWarnings) {
                     ShowWarningError(
                         state,
-                        format("{}={}:  Heating Seasonal Performance Factor calculated is not at the AHRI test condition.", DXCoilType, DXCoilName));
+                        format("{}={}:  Heating Seasonal Performance Factor calculated is not at the AHRI test condition.", HVAC::coilTypeNames[(int)coilType], DXCoilName));
                     ShowContinueError(state, " Review the Standard Ratings calculations in the Engineering Reference for this coil type.");
                     if (HeatingCapCurveHSPFLimitsExceeded) {
                         ShowContinueError(
@@ -7482,7 +7446,8 @@ namespace StandardRatings {
             //   MultiSpeed DX Coil Net Cooling Capacity and SEER:
             break;
         }
-        case CoilDX_MultiSpeedCooling: {
+
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             bool CapCurveLowOATLimitsExceeded = false; // Logical for capacity curve temperature limits being exceeded (low temp)
             bool EIRCurveLowOATLimitsExceeded = false; // Logical for EIR curve temperature limits being exceeded (Low temp)
 
@@ -7526,7 +7491,7 @@ namespace StandardRatings {
                 ShowWarningError(
                     state,
                     format("The Standard Ratings is calculated for {} = {} but not at the AHRI test condition due to curve out of bound.",
-                           DXCoilType,
+                           HVAC::coilTypeNames[(int)coilType],
                            DXCoilName));
                 ShowContinueError(state,
                                   " Review the Standard Ratings calculations in the Engineering Reference for this coil type. Also, use "
@@ -7543,7 +7508,7 @@ namespace StandardRatings {
                     if (state.dataGlobal->DisplayExtraWarnings) {
                         ShowContinueError(state,
                                           format("{}={}:  The Standard Rating Cooling Capacity calculated is not at the AHRI test condition.",
-                                                 DXCoilType,
+                                                 HVAC::coilTypeNames[(int)coilType],
                                                  DXCoilName));
                         if (CapCurveHighOATLimitsExceeded) {
                             ShowContinueError(
@@ -7568,7 +7533,7 @@ namespace StandardRatings {
                     if (state.dataGlobal->DisplayExtraWarnings) {
                         ShowContinueError(state,
                                           format("{}={}:  The Seasonal Energy Efficiency Ratio (SEER) calculated is not at the AHRI test condition.",
-                                                 DXCoilType,
+                                                 HVAC::coilTypeNames[(int)coilType],
                                                  DXCoilName));
                         if (CapCurveLowOATLimitsExceeded) {
                             ShowContinueError(
@@ -7605,7 +7570,8 @@ namespace StandardRatings {
 
             break;
         }
-        case CoilDX_MultiSpeedHeating: {
+          
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
 
             bool CapCurveOATLimitsExceeded = false; // Logical for capacity curve OD temp. limits being exceeded (low and High)
             {
@@ -7664,7 +7630,7 @@ namespace StandardRatings {
                 ShowWarningError(
                     state,
                     format("The Standard Ratings is calculated for {} = {} but not at the AHRI test condition due to curve out of bound.",
-                           DXCoilType,
+                           HVAC::coilTypeNames[(int)coilType],
                            DXCoilName));
                 ShowContinueError(state,
                                   " Review the Standard Ratings calculations in the Engineering Reference for this coil type. Also, use "
@@ -7679,7 +7645,7 @@ namespace StandardRatings {
             if (CapCurveOATLimitsExceeded) {
                 if (state.dataGlobal->DisplayExtraWarnings) {
                     ShowWarningError(
-                        state, format("{}={}:  The Net Heating Capacity Calculated is not at the AHRI test condition.", DXCoilType, DXCoilName));
+                        state, format("{}={}:  The Net Heating Capacity Calculated is not at the AHRI test condition.", HVAC::coilTypeNames[(int)coilType], DXCoilName));
                     ShowContinueError(
                         state,
                         format(" Check limits in Total Heating Capacity Function of Temperature Curve, Curve Type = {}, Curve Name = {}",
@@ -7692,7 +7658,7 @@ namespace StandardRatings {
                 if (state.dataGlobal->DisplayExtraWarnings) {
                     ShowWarningError(state,
                                      format("{}={}:  The Heating Seasonal Performance Factor calculated is not at the AHRI test condition.",
-                                            DXCoilType,
+                                            HVAC::coilTypeNames[(int)coilType],
                                             DXCoilName));
                     if (HeatingCapCurveHSPFLimitsExceeded) {
                         ShowContinueError(
diff --git a/src/EnergyPlus/StandardRatings.hh b/src/EnergyPlus/StandardRatings.hh
index ba90834f980..84d6f9f5c84 100644
--- a/src/EnergyPlus/StandardRatings.hh
+++ b/src/EnergyPlus/StandardRatings.hh
@@ -174,8 +174,7 @@ namespace StandardRatings {
     void CalcDXCoilStandardRating(
         EnergyPlusData &state,
         std::string const &DXCoilName,                             // Name of DX coil for which HSPF is calculated
-        std::string const &DXCoilType,                             // Type of DX coil for which HSPF is calculated
-        int const DXCoilType_Num,                                  // Integer Type of DX coil - heating or cooling
+        HVAC::CoilType coilType,                                  // Integer Type of DX coil - heating or cooling
         int const ns,                                              // Number of compressor speeds
         Array1A<Real64> const RatedTotalCapacity,                  // Reference capacity of DX coil [W]
         Array1A<Real64> const RatedCOP,                            // Reference coefficient of performance [W/W]
@@ -206,8 +205,7 @@ namespace StandardRatings {
 
     void CalcTwoSpeedDXCoilRating(EnergyPlusData &state,
                                   std::string const &DXCoilName,
-                                  std::string const &DXCoilType,
-                                  int const DXCoilType_Num,
+                                  HVAC::CoilType coilType,
                                   Array1A<Real64> const &RatedTotalCapacity,
                                   Real64 const RatedTotCap2,
                                   Array1A<Real64> const &RatedCOP,
@@ -225,10 +223,10 @@ namespace StandardRatings {
                                   Array1D<DataHeatBalance::RefrigCondenserType> const &CondenserType,
                                   int const PLFFPLRCurveIndex);
 
+    // Why are all parameters passed by reference?
     std::map<std::string, Real64> TwoSpeedDXCoilStandardRatings(EnergyPlusData &state,
                                                                 std::string const &DXCoilName,
-                                                                std::string const &DXCoilType,
-                                                                int const &DXCoilType_Num,
+                                                                HVAC::CoilType const coilType,
                                                                 Array1A<Real64> const &RatedTotalCapacity,
                                                                 Real64 const &RatedTotCap2,
                                                                 Array1A<Real64> const &RatedCOP,
@@ -255,7 +253,8 @@ namespace StandardRatings {
     // Real64 HSPF_2023 <- seasonale energy efficiency ratio of multi speed DX cooling coil
     std::map<std::string, Real64> SingleSpeedDXHeatingCoilStandardRatings(
         EnergyPlusData &state,
-        std::string const &DXCoilType,                                 // Type of DX coil for which HSPF is calculated
+        std::string const &coilName,
+        HVAC::CoilType coilType,                                 // Type of DX coil for which HSPF is calculated
         Real64 const RatedTotalCapacity,                               // Reference capacity of DX coil [W]
         Real64 const RatedCOP,                                         // Reference coefficient of performance [W/W]
         int const CapFFlowCurveIndex,                                  // Index for the capacity as a function of flow fraction modifier curve
@@ -315,7 +314,7 @@ namespace StandardRatings {
     std::map<std::string, Real64> SingleSpeedDXCoolingCoilStandardRatings(
         EnergyPlusData &state,
         std::string const &DXCoilName,                         // Name of DX coil for which HSPF is calculated
-        std::string const &DXCoilType,                         // Type of DX coil - heating or cooling
+        HVAC::CoilType coilType,                         // Type of DX coil - heating or cooling
         int const CapFTempCurveIndex,                          // Index for the capacity as a function of temperature modifier curve
         int const CapFFlowCurveIndex,                          // Index for the capacity as a function of flow fraction modifier curve
         int const EIRFTempCurveIndex,                          // Index for the EIR as a function of temperature modifier curve
@@ -344,7 +343,7 @@ namespace StandardRatings {
     // Real64 IEER -> Integareted energy efficiency ratio of CurveFit DX cooling coil
     // Real64 EER -> Energy efficiency ratio at high speed for CurveFit DX cooling coil
     std::tuple<Real64, Real64, Real64>
-    IEERCalulcationCurveFit(EnergyPlusData &state, std::string const &CoilType, EnergyPlus::CoilCoolingDXCurveFitOperatingMode operatingMode);
+    IEERCalulcationCurveFit(EnergyPlusData &state, HVAC::CoilType coilType, EnergyPlus::CoilCoolingDXCurveFitOperatingMode operatingMode);
 
     // NetCoolingCapRatedMaxSpeed2023 --> net cooling capacity at maximum speed
     // SEER2_User --> seasonal energy efficiency ratio of multi speed DX cooling coil, from user-input PLF curve and C_D value
@@ -352,7 +351,7 @@ namespace StandardRatings {
     // curve and  C_D value
     // EER2 --> Energy Efficiency Ratio from std 210/240-2023 at AFull
     std::tuple<Real64, Real64, Real64, Real64>
-    SEER2CalulcationCurveFit(EnergyPlusData &state, std::string const &CoilType, EnergyPlus::CoilCoolingDXCurveFitOperatingMode operatingMode);
+    SEER2CalulcationCurveFit(EnergyPlusData &state, HVAC::CoilType coilType, EnergyPlus::CoilCoolingDXCurveFitOperatingMode operatingMode);
 
     // Calculations as per AHRI 340/360 Standard 2022
     // Real64 NetCoolingCapRated -> Net cooling capacity at high speed for Variable Speed DX Cooling Coil
@@ -360,7 +359,7 @@ namespace StandardRatings {
     // Real64 EER -> Energy efficiency ratio at high speed for Variable Speed DX cooling coil
     std::tuple<Real64, Real64, Real64> IEERCalculationVariableSpeed(
         EnergyPlusData &state,
-        std::string const &VSCoilType, //
+        HVAC::CoilType coilType,
         int const nsp,
         Array1A_int const &CapFTempCurveIndex,
         Array1A<Real64> const &RatedTotalCapacity, // Rated gross total cooling capacity
@@ -378,7 +377,7 @@ namespace StandardRatings {
     // Real64 EER -> Energy efficiency ratio at high speed for MultiSpeed DX cooling coil
     std::tuple<Real64, Real64, Real64> IEERCalculationMultiSpeed(
         EnergyPlusData &state,
-        std::string const &DXCoilType, // Type of DX coil
+        HVAC::CoilType coilType,
         int const nsp,                 // Number of Speeds
         Array1A_int const &CapFTempCurveIndex,
         Array1A<Real64> const &RatedTotalCapacity, // Rated gross total cooling capacity
@@ -396,7 +395,7 @@ namespace StandardRatings {
     // Real64 EER -> Energy efficiency ratio at high speed for Two Speed DX cooling coil
     std::tuple<Real64, Real64, Real64> IEERCalculationTwoSpeed(
         EnergyPlusData &state,
-        std::string const &DXCoilType,                                      // Type of DX coil
+        HVAC::CoilType coilType,
         Array1D<DataHeatBalance::RefrigCondenserType> const &CondenserType, // Type of condenser user by the DX Cooling Coil
         Array1A_int const &CapFTempCurveIndex,
         Array1A<Real64> const &RatedTotalCapacity,         // Rated gross total cooling capacity
@@ -414,7 +413,7 @@ namespace StandardRatings {
     // Real64 EER -> Energy efficiency ratio for Single Speed DX cooling coil
     std::tuple<Real64, Real64, Real64> IEERCalculationSingleSpeed(
         EnergyPlus::EnergyPlusData &state,
-        std::string const &DXCoilType,           // Type of DX coil
+        HVAC::CoilType coilType,
         const int CapFTempCurveIndex,            // Index for the capacity as a function of temperature modifier curve
         const Real64 RatedTotalCapacity,         // Rated gross total cooling capacity
         const Real64 TotCapFlowModFac,           // Total capacity modifier f(actual flow vs rated flow) for each speed [-]
@@ -453,7 +452,7 @@ namespace StandardRatings {
     void DXCoolingCoilDataCenterStandardRatings(
         EnergyPlusData &state,
         std::string const &DXCoilName,                    // Name of DX coil for which HSPF is calculated
-        std::string const &DXCoilType,                    // Type of DX coil - heating or cooling
+        HVAC::CoilType coilType,                    // Type of DX coil - heating or cooling
         int const CapFTempCurveIndex,                     // Index for the capacity as a function of temperature modifier curve
         int const CapFFlowCurveIndex,                     // Index for the capacity as a function of flow fraction modifier curve
         int const EIRFTempCurveIndex,                     // Index for the EIR as a function of temperature modifier curve
@@ -550,8 +549,8 @@ namespace StandardRatings {
     //                       default C_D value
     std::map<std::string, Real64> VariableSpeedDXCoolingCoilStandardRatings(
         EnergyPlusData &state,
-        std::string const &DXCoilType,                                  // Type of DX coil for which HSPF is calculated
         std::string const &DXCoilName,                                  // Name of DX coil for which standard ratings are calculated
+        HVAC::CoilType coilType,
         Array1A_int const CapFTempCurveIndex,                           // Index for the capacity as a function of temperature modifier curve
         Array1A_int const CapFFlowCurveIndex,                           // Index for the capacity as a function of flow fraction modifier curve
         Array1A_int const EIRFTempCurveIndex,                           // Index for the EIR as a function of temperature modifier curve
@@ -578,8 +577,8 @@ namespace StandardRatings {
     //                       default C_D value
     std::map<std::string, Real64> MultiSpeedDXCoolingCoilStandardRatings(
         EnergyPlusData &state,
-        std::string const &DXCoilType,                                  // Type of DX coil for which HSPF is calculated
         std::string const &DXCoilName,                                  // Name of DX coil for which standard Ratings are calculated
+        HVAC::CoilType coilType,
         Array1A_int const CapFTempCurveIndex,                           // Index for the capacity as a function of temperature modifier curve
         Array1A_int const CapFFlowCurveIndex,                           // Index for the capacity as a function of flow fraction modifier curve
         Array1A_int const EIRFTempCurveIndex,                           // Index for the EIR as a function of temperature modifier curve
@@ -643,7 +642,7 @@ namespace StandardRatings {
     std::map<std::string, Real64> MultiSpeedDXHeatingCoilStandardRatings(
         EnergyPlusData &state,
         std::string const &DXCoilName,                                 // Name of DX coil for which HSPF is calculated
-        std::string const &DXCoilType,                                 // Type of DX coil for which HSPF is calculated
+        HVAC::CoilType coilType,
         Array1A_int const CapFTempCurveIndex,                          // Index for the capacity as a function of temperature modifier curve
         Array1A_int const CapFFlowCurveIndex,                          // Index for the capacity as a function of flow fraction modifier curve
         Array1A_int const EIRFTempCurveIndex,                          // Index for the EIR as a function of temperature modifier curve
@@ -663,9 +662,8 @@ namespace StandardRatings {
     );
 
     void ReportDXCoilRating(EnergyPlusData &state,
-                            std::string const &CompType,     // Type of component
-                            std::string_view CompName,       // Name of component
-                            int const CompTypeNum,           // TypeNum of component
+                            std::string const &CompName,       // Name of component
+                            HVAC::CoilType coilType,           // TypeNum of component
                             Real64 const CoolCapVal,         // Standard total (net) cooling capacity for AHRI Std. 210/240 {W}
                             Real64 const SEERValueIP,        // SEER value in IP units from user PLR curve {Btu/W-h}
                             Real64 const SEERValueDefaultIP, // SEER value in IP units from AHRI Std 210/240-2008 default PLF curve and C_D {Btu/W-h}
@@ -679,17 +677,15 @@ namespace StandardRatings {
                             bool const AHRI2023StandardRatings = false); // True if required AHRI/ANSI 210/240 Std. 2023 SEER2,HSPF2 Ratings.
 
     void ReportDXCoolCoilDataCenterApplication(EnergyPlusData &state,
-                                               std::string const &CompType,           // Type of component
-                                               std::string_view CompName,             // Name of component
-                                               int const CompTypeNum,                 // TypeNum of component
+                                               std::string const &CompName,             // Name of component
+                                               HVAC::CoilType const coilType,                 // TypeNum of component
                                                Array1D<Real64> &NetCoolingCapRated,   // net cooling capacity of single speed DX cooling coil
                                                Array1D<Real64> &TotElectricPowerRated // total electric power including supply fan
     );
 
     void CheckCurveLimitsForStandardRatings(EnergyPlusData &state,
                                             std::string const &DXCoilName, // Name of DX coil for which HSPF is calculated
-                                            std::string const &DXCoilType, // Type of DX coil - heating or cooling
-                                            int const DXCoilTypeNum,       // Integer type of DX coil - heating or cooling
+                                            HVAC::CoilType coilType,       // Integer type of DX coil - heating or cooling
                                             int const CapFTempCurveIndex,  // Index for the capacity as a function of temperature modifier curve
                                             int const CapFFlowCurveIndex,  // Index for the capacity as a function of flow fraction modifier curve
                                             int const EIRFTempCurveIndex,  // Index for the EIR as a function of temperature modifier curve
diff --git a/src/EnergyPlus/SteamCoils.cc b/src/EnergyPlus/SteamCoils.cc
index 837020a62eb..bb1f7469f8c 100644
--- a/src/EnergyPlus/SteamCoils.cc
+++ b/src/EnergyPlus/SteamCoils.cc
@@ -105,7 +105,7 @@ namespace SteamCoils {
     void SimulateSteamCoilComponents(EnergyPlusData &state,
                                      std::string_view CompName,
                                      bool const FirstHVACIteration,
-                                     int &CompIndex,
+                                     int &coilNum,
                                      ObjexxFCL::Optional<Real64 const> QCoilReq, // coil load to be met
                                      ObjexxFCL::Optional<Real64> QCoilActual,    // coil load actually delivered returned to calling component
                                      ObjexxFCL::Optional<HVAC::FanOp const> fanOpMode,
@@ -122,11 +122,7 @@ namespace SteamCoils {
         // This subroutine manages SteamCoil component simulation.
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        Real64 QCoilActualTemp; // coil load actually delivered returned to calling component
         int CoilNum;            // The SteamCoil that you are currently loading input into
-        HVAC::FanOp fanOp;      // fan operating mode
-        Real64 PartLoadFrac;    // part-load fraction of heating coil
-        Real64 QCoilReqLocal;   // local required heating load optional
 
         // Obtains and Allocates SteamCoil related parameters from input file
         if (state.dataSteamCoils->GetSteamCoilsInputFlag) { // First time subroutine has been entered
@@ -135,36 +131,62 @@ namespace SteamCoils {
         }
 
         // Find the correct SteamCoilNumber with the Coil Name
-        if (CompIndex == 0) {
-            CoilNum = Util::FindItemInList(CompName, state.dataSteamCoils->SteamCoil);
-            if (CoilNum == 0) {
+        if (coilNum == 0) {
+            coilNum = Util::FindItemInList(CompName, state.dataSteamCoils->SteamCoil);
+            if (coilNum == 0) {
                 ShowFatalError(state, format("SimulateSteamCoilComponents: Coil not found={}", CompName));
             }
-            CompIndex = CoilNum;
         } else {
-            CoilNum = CompIndex;
-            if (CoilNum > state.dataSteamCoils->NumSteamCoils || CoilNum < 1) {
+            if (coilNum > state.dataSteamCoils->NumSteamCoils || coilNum < 1) {
                 ShowFatalError(state,
                                format("SimulateSteamCoilComponents: Invalid CompIndex passed={}, Number of Steam Coils={}, Coil name={}",
-                                      CoilNum,
+                                      coilNum,
                                       state.dataSteamCoils->NumSteamCoils,
                                       CompName));
             }
-            if (state.dataSteamCoils->CheckEquipName(CoilNum)) {
-                if (CompName != state.dataSteamCoils->SteamCoil(CoilNum).Name) {
+            if (state.dataSteamCoils->CheckEquipName(coilNum)) {
+                if (CompName != state.dataSteamCoils->SteamCoil(coilNum).Name) {
                     ShowFatalError(
                         state,
                         format("SimulateSteamCoilComponents: Invalid CompIndex passed={}, Coil name={}, stored Coil Name for that index={}",
-                               CoilNum,
+                               coilNum,
                                CompName,
-                               state.dataSteamCoils->SteamCoil(CoilNum).Name));
+                               state.dataSteamCoils->SteamCoil(coilNum).Name));
                 }
-                state.dataSteamCoils->CheckEquipName(CoilNum) = false;
+                state.dataSteamCoils->CheckEquipName(coilNum) = false;
             }
         }
 
+        SimulateSteamCoilComponents(state, coilNum, FirstHVACIteration, QCoilReq, QCoilActual, fanOpMode, PartLoadRatio);
+
+    }
+
+    void SimulateSteamCoilComponents(EnergyPlusData &state,
+                                     int coilNum,
+                                     bool const FirstHVACIteration,
+                                     ObjexxFCL::Optional<Real64 const> QCoilReq, // coil load to be met
+                                     ObjexxFCL::Optional<Real64> QCoilActual,    // coil load actually delivered returned to calling component
+                                     ObjexxFCL::Optional<HVAC::FanOp const> fanOpMode,
+                                     ObjexxFCL::Optional<Real64 const> PartLoadRatio)
+    {
+
+        // SUBROUTINE INFORMATION:
+        //   AUTHOR         Rahul Chillar
+        //   DATE WRITTEN   Jan 2005
+        //   MODIFIED       na
+        //   RE-ENGINEERED  na
+
+        // PURPOSE OF THIS SUBROUTINE:
+        // This subroutine manages SteamCoil component simulation.
+
+        // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
+        Real64 QCoilActualTemp; // coil load actually delivered returned to calling component
+        HVAC::FanOp fanOp;      // fan operating mode
+        Real64 PartLoadFrac;    // part-load fraction of heating coil
+        Real64 QCoilReqLocal;   // local required heating load optional
+
         // With the correct CoilNum Initialize
-        InitSteamCoil(state, CoilNum, FirstHVACIteration); // Initialize all SteamCoil related parameters
+        InitSteamCoil(state, coilNum, FirstHVACIteration); // Initialize all SteamCoil related parameters
 
         if (present(fanOpMode)) {
             fanOp = fanOpMode;
@@ -182,17 +204,18 @@ namespace SteamCoils {
             QCoilReqLocal = 0.0;
         }
 
-        CalcSteamAirCoil(
-            state, CoilNum, QCoilReqLocal, QCoilActualTemp, fanOp, PartLoadFrac); // Autodesk:OPTIONAL QCoilReq used without PRESENT check
+        CalcSteamAirCoil(state, coilNum, QCoilReqLocal, QCoilActualTemp, fanOp, PartLoadFrac);
+
+        // Autodesk:OPTIONAL QCoilReq used without PRESENT check
         if (present(QCoilActual)) QCoilActual = QCoilActualTemp;
 
         // Update the current SteamCoil to the outlet nodes
-        UpdateSteamCoil(state, CoilNum);
+        UpdateSteamCoil(state, coilNum);
 
         // Report the current SteamCoil
-        ReportSteamCoil(state, CoilNum);
+        ReportSteamCoil(state, coilNum);
     }
-
+  
     // Get Input Section of the Module
 
     void GetSteamCoilInput(EnergyPlusData &state)
@@ -822,10 +845,10 @@ namespace SteamCoils {
                 // Coil report, set fan info for airloopnum
 
                 if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum > 0) {
-                    state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
+                    ReportCoilSelection::setCoilSupplyFanInfo(
                         state,
                         state.dataSteamCoils->SteamCoil(CoilNum).Name,
-                        "Coil:Heating:Steam",
+                        state.dataSteamCoils->SteamCoil(CoilNum).coilType,
                         state.dataFans->fans(state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum)->Name,
                         state.dataFans->fans(state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum)->type,
                         state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanNum);
@@ -903,9 +926,9 @@ namespace SteamCoils {
         RegisterPlantCompDesignFlow(
             state, state.dataSteamCoils->SteamCoil(CoilNum).SteamInletNodeNum, state.dataSteamCoils->SteamCoil(CoilNum).MaxSteamVolFlowRate);
 
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(state,
+        ReportCoilSelection::setCoilHeatingCapacity(state,
                                                                                    state.dataSteamCoils->SteamCoil(CoilNum).Name,
-                                                                                   "Coil:Heating:Steam",
+                                                                                   state.dataSteamCoils->SteamCoil(CoilNum).coilType,
                                                                                    DesCoilLoad,
                                                                                    coilWasAutosized,
                                                                                    state.dataSize->CurSysNum,
@@ -915,34 +938,34 @@ namespace SteamCoils {
                                                                                    1.0,
                                                                                    -999.0,
                                                                                    -999.0);
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(state,
+        ReportCoilSelection::setCoilWaterFlowNodeNums(state,
                                                                                      state.dataSteamCoils->SteamCoil(CoilNum).Name,
-                                                                                     "Coil:Heating:Steam",
+                                                                                     state.dataSteamCoils->SteamCoil(CoilNum).coilType,
                                                                                      state.dataSteamCoils->SteamCoil(CoilNum).MaxSteamVolFlowRate,
                                                                                      coilWasAutosized,
                                                                                      state.dataSteamCoils->SteamCoil(CoilNum).SteamInletNodeNum,
                                                                                      state.dataSteamCoils->SteamCoil(CoilNum).SteamOutletNodeNum,
                                                                                      state.dataSteamCoils->SteamCoil(CoilNum).plantLoc.loopNum);
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterHeaterCapacityNodeNums(
+        ReportCoilSelection::setCoilWaterHeaterCapacityNodeNums(
             state,
             state.dataSteamCoils->SteamCoil(CoilNum).Name,
-            "Coil:Heating:Steam",
+            state.dataSteamCoils->SteamCoil(CoilNum).coilType,
             DesCoilLoad,
             coilWasAutosized,
             state.dataSteamCoils->SteamCoil(CoilNum).SteamInletNodeNum,
             state.dataSteamCoils->SteamCoil(CoilNum).SteamOutletNodeNum,
             state.dataSteamCoils->SteamCoil(CoilNum).plantLoc.loopNum);
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(
-            state, state.dataSteamCoils->SteamCoil(CoilNum).Name, "Coil:Heating:Steam", TempSteamIn); // coil  report
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
+        ReportCoilSelection::setCoilEntWaterTemp(
+            state, state.dataSteamCoils->SteamCoil(CoilNum).Name, state.dataSteamCoils->SteamCoil(CoilNum).coilType, TempSteamIn); // coil  report
+        ReportCoilSelection::setCoilLvgWaterTemp(
             state,
             state.dataSteamCoils->SteamCoil(CoilNum).Name,
-            "Coil:Heating:Steam",
+            state.dataSteamCoils->SteamCoil(CoilNum).coilType,
             TempSteamIn - state.dataSteamCoils->SteamCoil(CoilNum).DegOfSubcooling); // coil report
-        state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(
+        ReportCoilSelection::setCoilWaterDeltaT(
             state,
             state.dataSteamCoils->SteamCoil(CoilNum).Name,
-            "Coil:Heating:Steam",
+            state.dataSteamCoils->SteamCoil(CoilNum).coilType,
             state.dataSteamCoils->SteamCoil(CoilNum).DegOfSubcooling); // coil report
         state.dataSteamCoils->SteamCoil(CoilNum).DesCoilCapacity = DesCoilLoad;
         state.dataSteamCoils->SteamCoil(CoilNum).DesAirVolFlow = DesVolFlow;
@@ -951,9 +974,9 @@ namespace SteamCoils {
         }
 
         // There is no standard rating for heating coils at this point, so fill with dummy flag values
-        state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(state,
+        ReportCoilSelection::setRatedCoilConditions(state,
                                                                                    state.dataSteamCoils->SteamCoil(CoilNum).Name,
-                                                                                   "Coil:Heating:Steam",
+                                                                                   state.dataSteamCoils->SteamCoil(CoilNum).coilType,
                                                                                    -999.0,
                                                                                    -999.0,
                                                                                    -999.0,
@@ -1479,10 +1502,10 @@ namespace SteamCoils {
 
     // Utility subroutines for the SteamCoil Module
 
-    int GetSteamCoilIndex(EnergyPlusData &state,
-                          std::string_view CoilType,   // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
+    int GetCoilIndex(EnergyPlusData &state,
+                     std::string_view CoilType,   // must match coil types in this module
+                     std::string const &CoilName, // must match coil names for the coil type
+                     bool &ErrorsFound            // set to true if problem
     )
     {
 
@@ -1520,6 +1543,19 @@ namespace SteamCoils {
         return IndexNum;
     }
 
+    int GetCoilIndex(EnergyPlusData &state,
+                     std::string const &CoilName // must match coil names for the coil type
+    )
+    {
+        if (state.dataSteamCoils->GetSteamCoilsInputFlag) { // First time subroutine has been entered
+            GetSteamCoilInput(state);
+            state.dataSteamCoils->GetSteamCoilsInputFlag = false;
+        }
+
+        return Util::FindItemInList(CoilName, state.dataSteamCoils->SteamCoil);
+    }
+
+
     int GetCompIndex(EnergyPlusData &state, std::string_view const coilName)
     {
         if (state.dataSteamCoils->GetSteamCoilsInputFlag) { // First time subroutine has been entered
@@ -1974,7 +2010,7 @@ namespace SteamCoils {
     }
 
     Real64 GetCoilCapacity(EnergyPlusData &state,
-                           std::string const &CoilType, // must match coil types in this module
+                           std::string_view const CoilType, // must match coil types in this module
                            std::string const &CoilName, // must match coil names for the coil type
                            bool &ErrorsFound            // set to true if problem
     )
@@ -2197,6 +2233,61 @@ namespace SteamCoils {
     }
     // End of Utility subroutines for the SteamCoil Module
 
+    // New API
+    Real64 GetCoilMaxSteamFlowRate(EnergyPlusData &state, int const coilNum) 
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).MaxSteamVolFlowRate;
+    }
+    
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return 0.0;
+    }
+    
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).AirInletNodeNum;
+    }
+  
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).AirOutletNodeNum;
+    }
+  
+    int GetCoilSteamInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).SteamInletNodeNum;
+    }
+    
+    int GetCoilSteamOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).SteamOutletNodeNum;
+    }
+    
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum)  
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).availSched->getCurrentVal(); // not scheduled?
+    }
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).OperatingCapacity;
+    }
+
+    int GetCoilControlNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataSteamCoils->NumSteamCoils);
+        return state.dataSteamCoils->SteamCoil(coilNum).TempSetPointNodeNum;
+    }
+
 } // namespace SteamCoils
 
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/SteamCoils.hh b/src/EnergyPlus/SteamCoils.hh
index 0133739d11a..1ed0dfc358a 100644
--- a/src/EnergyPlus/SteamCoils.hh
+++ b/src/EnergyPlus/SteamCoils.hh
@@ -56,6 +56,7 @@
 #include <EnergyPlus/Data/BaseData.hh>
 #include <EnergyPlus/DataGlobals.hh>
 #include <EnergyPlus/EnergyPlus.hh>
+
 #include <EnergyPlus/FluidProperties.hh>
 
 namespace EnergyPlus {
@@ -77,42 +78,46 @@ namespace SteamCoils {
     struct SteamCoilEquipConditions
     {
         // Members
-        std::string Name;                      // Name of the SteamCoil
-        std::string SteamCoilTypeA;            // Type of SteamCoil ie. Heating or Cooling
-        int SteamCoilType;                     // Type of SteamCoil ie. Heating or Cooling
-        int SteamCoilModel;                    // Type of SteamCoil ie. Simple, Detailed, etc.
+        std::string Name;                 // Name of the SteamCoil
+        HVAC::CoilType coilType = HVAC::CoilType::HeatingSteam;
+      
+        std::string SteamCoilTypeA;       // Type of SteamCoil ie. Heating or Cooling
+        int SteamCoilType;                // Type of SteamCoil ie. Heating or Cooling
+        int SteamCoilModel;               // Type of SteamCoil ie. Simple, Detailed, etc.
+
         Sched::Schedule *availSched = nullptr; // operating schedule
-        Real64 InletAirMassFlowRate;           // MassFlow through the SteamCoil being Simulated [kg/s]
-        Real64 OutletAirMassFlowRate;          // MassFlow throught the SteamCoil being Simulated[kg/s]
-        Real64 InletAirTemp;                   // Inlet Air Temperature Operating Condition [C]
-        Real64 OutletAirTemp;                  // Outlet Air Temperature Operating Condition [C]
-        Real64 InletAirHumRat;                 // Inlet Air Humidity Ratio Operating Condition
-        Real64 OutletAirHumRat;                // Outlet Air Humidity Ratio Calculated Condition
-        Real64 InletAirEnthalpy;               // Inlet Air enthalpy [J/kg]
-        Real64 OutletAirEnthalpy;              // Outlet Air enthalpy [J/kg]
-        Real64 TotSteamCoilLoad;               // Total Load on the Coil [W]
-        Real64 SenSteamCoilLoad;               // Sensible Load on the Coil [W]
-        Real64 TotSteamHeatingCoilEnergy;      // Total Heating Coil energy of the Coil [J]
-        Real64 TotSteamCoolingCoilEnergy;      // Total Cooling Coil energy of the Coil [J]
-        Real64 SenSteamCoolingCoilEnergy;      // Sensible Cooling Coil energy of the Coil [J]
-        Real64 TotSteamHeatingCoilRate;        // Total Heating Coil Rate on the Coil [W]
-        Real64 LoopLoss;                       // Loss in loop due to cond return to atm pressure
-        Real64 TotSteamCoolingCoilRate;        // Total Cooling Coil Rate on the Coil [W]
-        Real64 SenSteamCoolingCoilRate;        // Sensible Cooling Coil Rate on the Coil [W]
-        Real64 LeavingRelHum;                  // Simple Coil Latent Model requires User input for leaving RH
-        Real64 DesiredOutletTemp;              // Temp desired at the outlet (C)
-        Real64 DesiredOutletHumRat;            // Humudity Ratio desired at outlet (C)
-        Real64 InletSteamTemp;                 // Inlet Steam Temperature [C]
-        Real64 OutletSteamTemp;                // Outlet Steam Temperature [C]
-        Real64 InletSteamMassFlowRate;         // Inlet Steam Mass Flow Rate [Kg/s]
-        Real64 OutletSteamMassFlowRate;        // Outlet Steam Mass Flow Rate [Kg/s]
-        Real64 MaxSteamVolFlowRate;            // Maximum water Volume flow rate [m3/s]
-        Real64 MaxSteamMassFlowRate;           // Maximum water mass flow rate [Kg/s]
-        Real64 InletSteamEnthalpy;             // Inlet Water Enthalpy (J/Kg)
-        Real64 OutletWaterEnthalpy;            // Outlet Water Enthalpy (J/kg)
-        Real64 InletSteamPress;                // Pressure at steam inlet (Pa)
-        Real64 InletSteamQuality;              // Quality of steam at inlet
-        Real64 OutletSteamQuality;             // Quality of steam at outlet
+      
+        Real64 InletAirMassFlowRate;      // MassFlow through the SteamCoil being Simulated [kg/s]
+        Real64 OutletAirMassFlowRate;     // MassFlow throught the SteamCoil being Simulated[kg/s]
+        Real64 InletAirTemp;              // Inlet Air Temperature Operating Condition [C]
+        Real64 OutletAirTemp;             // Outlet Air Temperature Operating Condition [C]
+        Real64 InletAirHumRat;            // Inlet Air Humidity Ratio Operating Condition
+        Real64 OutletAirHumRat;           // Outlet Air Humidity Ratio Calculated Condition
+        Real64 InletAirEnthalpy;          // Inlet Air enthalpy [J/kg]
+        Real64 OutletAirEnthalpy;         // Outlet Air enthalpy [J/kg]
+        Real64 TotSteamCoilLoad;          // Total Load on the Coil [W]
+        Real64 SenSteamCoilLoad;          // Sensible Load on the Coil [W]
+        Real64 TotSteamHeatingCoilEnergy; // Total Heating Coil energy of the Coil [J]
+        Real64 TotSteamCoolingCoilEnergy; // Total Cooling Coil energy of the Coil [J]
+        Real64 SenSteamCoolingCoilEnergy; // Sensible Cooling Coil energy of the Coil [J]
+        Real64 TotSteamHeatingCoilRate;   // Total Heating Coil Rate on the Coil [W]
+        Real64 LoopLoss;                  // Loss in loop due to cond return to atm pressure
+        Real64 TotSteamCoolingCoilRate;   // Total Cooling Coil Rate on the Coil [W]
+        Real64 SenSteamCoolingCoilRate;   // Sensible Cooling Coil Rate on the Coil [W]
+        Real64 LeavingRelHum;             // Simple Coil Latent Model requires User input for leaving RH
+        Real64 DesiredOutletTemp;         // Temp desired at the outlet (C)
+        Real64 DesiredOutletHumRat;       // Humudity Ratio desired at outlet (C)
+        Real64 InletSteamTemp;            // Inlet Steam Temperature [C]
+        Real64 OutletSteamTemp;           // Outlet Steam Temperature [C]
+        Real64 InletSteamMassFlowRate;    // Inlet Steam Mass Flow Rate [Kg/s]
+        Real64 OutletSteamMassFlowRate;   // Outlet Steam Mass Flow Rate [Kg/s]
+        Real64 MaxSteamVolFlowRate;       // Maximum water Volume flow rate [m3/s]
+        Real64 MaxSteamMassFlowRate;      // Maximum water mass flow rate [Kg/s]
+        Real64 InletSteamEnthalpy;        // Inlet Water Enthalpy (J/Kg)
+        Real64 OutletWaterEnthalpy;       // Outlet Water Enthalpy (J/kg)
+        Real64 InletSteamPress;           // Pressure at steam inlet (Pa)
+        Real64 InletSteamQuality;         // Quality of steam at inlet
+        Real64 OutletSteamQuality;        // Quality of steam at outlet
         Real64 DegOfSubcooling;
         Real64 LoopSubcoolReturn;
         int AirInletNodeNum;                                   // Inlet node number at air side
@@ -159,6 +164,14 @@ namespace SteamCoils {
                                      ObjexxFCL::Optional<HVAC::FanOp const> fanOp = _,
                                      ObjexxFCL::Optional<Real64 const> PartLoadRatio = _);
 
+    void SimulateSteamCoilComponents(EnergyPlusData &state,
+                                     int const coilNum,
+                                     bool FirstHVACIteration,
+                                     ObjexxFCL::Optional<Real64 const> QCoilReq = _, // coil load to be met
+                                     ObjexxFCL::Optional<Real64> QCoilActual = _,    // coil load actually delivered returned to calling component
+                                     ObjexxFCL::Optional<HVAC::FanOp const> fanOp = _,
+                                     ObjexxFCL::Optional<Real64 const> PartLoadRatio = _);
+  
     void GetSteamCoilInput(EnergyPlusData &state);
 
     void InitSteamCoil(EnergyPlusData &state, int CoilNum, bool FirstHVACIteration);
@@ -177,73 +190,22 @@ namespace SteamCoils {
 
     void ReportSteamCoil(EnergyPlusData &state, int CoilNum);
 
-    int GetSteamCoilIndex(EnergyPlusData &state,
-                          std::string_view CoilType,   // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
-    );
-    int GetCompIndex(EnergyPlusData &state, std::string_view coilName);
+#ifdef OLD_API  
+    int GetCoilIndex(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);           
 
-    void CheckSteamCoilSchedule(EnergyPlusData &state, std::string const &CompType, std::string_view CompName, Real64 &Value, int &CompIndex);
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, std::string_view const compType, std::string const &compName, bool &ErrorsFound);
 
-    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state,
-                                   std::string const &CoilType, // must match coil types in this module
-                                   std::string const &CoilName, // must match coil names for the coil type
-                                   bool &ErrorsFound            // set to true if problem
-    );
-
-    Real64 GetCoilMaxSteamFlowRate(EnergyPlusData &state,
-                                   int CoilIndex,    // must match coil types in this module
-                                   bool &ErrorsFound // set to true if problem
-    );
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilAirInletNode(EnergyPlusData &state,
-                            int CoilIndex,               // must match coil types in this module
-                            std::string const &CoilName, // must match coil names for the coil type
-                            bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilAirInletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &CoilName, bool &ErrorsFound);
 
-    int GetCoilAirOutletNode(EnergyPlusData &state,
-                             int CoilIndex,               // must match coil types in this module
-                             std::string const &CoilName, // must match coil names for the coil type
-                             bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilAirOutletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilAirOutletNode(EnergyPlusData &state,
-                             std::string const &CoilType, // must match coil types in this module
-                             std::string const &CoilName, // must match coil names for the coil type
-                             bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilSteamInletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &CoilName, bool &ErrorsFound);
 
-    int GetCoilSteamInletNode(EnergyPlusData &state,
-                              int CoilIndex,               // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilSteamOutletNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
-    int GetCoilSteamInletNode(EnergyPlusData &state,
-                              std::string const &CoilType, // must match coil types in this module
-                              std::string const &CoilName, // must match coil names for the coil type
-                              bool &ErrorsFound            // set to true if problem
-    );
-
-    int GetCoilSteamOutletNode(EnergyPlusData &state,
-                               int CoilIndex,               // must match coil types in this module
-                               std::string const &CoilName, // must match coil names for the coil type
-                               bool &ErrorsFound            // set to true if problem
-    );
-
-    int GetCoilSteamOutletNode(EnergyPlusData &state,
-                               std::string_view CoilType,   // must match coil types in this module
-                               std::string const &CoilName, // must match coil names for the coil type
-                               bool &ErrorsFound            // set to true if problem
-    );
-
-    Real64 GetCoilCapacity([[maybe_unused]] EnergyPlusData &state,
-                           std::string const &CoilType, // must match coil types in this module
-                           std::string const &CoilName, // must match coil names for the coil type
-                           bool &ErrorsFound            // set to true if problem
-    );
+    Real64 GetCoilCapacity(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
 
     CoilControlType GetTypeOfCoil(EnergyPlusData &state,
                                   int CoilIndex,               // must match coil types in this module
@@ -251,18 +213,10 @@ namespace SteamCoils {
                                   bool &ErrorsFound            // set to true if problem
     );
 
-    int GetSteamCoilControlNodeNum(EnergyPlusData &state,
-                                   std::string const &CoilType, // must match coil types in this module
-                                   std::string const &CoilName, // must match coil names for the coil type
-                                   bool &ErrorFlag              // set to true if problem
-    );
-
-    Sched::Schedule *GetSteamCoilAvailSchedule(EnergyPlusData &state,
-                                               std::string const &CoilType, // must match coil types in this module
-                                               std::string const &CoilName, // must match coil names for the coil type
-                                               bool &ErrorsFound            // set to true if problem
-    );
+    int GetCoilControlNode(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorFlag);
 
+    Sched::Schedule *GetCoilAvailSchedule(EnergyPlusData &state, std::string_view const coilType, std::string const &coilName, bool &ErrorsFound);
+#endif // OLD_API
     // sets data to a coil that is used as a regeneration air heating coil in
     // desiccant dehumidification system
     void SetSteamCoilData(EnergyPlusData &state,
@@ -272,6 +226,28 @@ namespace SteamCoils {
                           ObjexxFCL::Optional_int DesiccantDehumIndex = _         // Index for the desiccant dehum system where this coil is used
     );
 
+      int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
+  
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilMaxSteamFlowRate(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilSteamInletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilSteamOutletNode(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilControlNode(EnergyPlusData &state, int const coilNum);  
+
 } // namespace SteamCoils
 
 struct SteamCoilsData : BaseGlobalStruct
diff --git a/src/EnergyPlus/UnitHeater.cc b/src/EnergyPlus/UnitHeater.cc
index 12fe85ec57e..9e5ababccfc 100644
--- a/src/EnergyPlus/UnitHeater.cc
+++ b/src/EnergyPlus/UnitHeater.cc
@@ -220,6 +220,8 @@ namespace UnitHeater {
         int CtrlZone;                  // index to loop counter
         int NodeNum;                   // index to loop counter
 
+        auto &s_node = state.dataLoopNodes;
+        
         // Figure out how many unit heaters there are in the input file
         std::string CurrentModuleObject = state.dataUnitHeaters->cMO_UnitHeater;
         state.dataUnitHeaters->NumOfUnitHeats = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject);
@@ -341,52 +343,54 @@ namespace UnitHeater {
             }
 
             // Heating coil information:
-            {
-                unitHeat.Type = static_cast<HCoilType>(getEnumValue(HCoilTypeNamesUC, Util::makeUPPER(Alphas(7))));
-                switch (unitHeat.Type) {
-                case HCoilType::WaterHeatingCoil:
-                    unitHeat.HeatingCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-                    break;
-                case HCoilType::SteamCoil:
-                    unitHeat.HeatingCoilType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-                    break;
-                case HCoilType::Electric:
-                case HCoilType::Gas:
-                    break;
-                default: {
-                    ShowSevereError(state, format("Illegal {} = {}", cAlphaFields(7), Alphas(7)));
-                    ShowContinueError(state, format("Occurs in {}={}", CurrentModuleObject, unitHeat.Name));
-                    ErrorsFound = true;
-                    errFlag = true;
-                }
-                }
+            unitHeat.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(7)));
+            switch (unitHeat.heatCoilType) {
+            case HVAC::CoilType::HeatingWater: {
+                unitHeat.HeatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+            } break;
+
+            case HVAC::CoilType::HeatingSteam: {
+                unitHeat.HeatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+            } break;
+                  
+            case HVAC::CoilType::HeatingElectric:
+            case HVAC::CoilType::HeatingGasOrOtherFuel: {
+            } break;
+                  
+            default: {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(7), Alphas(7));
+                ErrorsFound = true;
+                errFlag = true;
+            } break;
             }
-
+            
             if (!errFlag) {
-                unitHeat.HCoilTypeCh = Alphas(7);
-                unitHeat.HCoilName = Alphas(8);
-                ValidateComponent(state, Alphas(7), unitHeat.HCoilName, IsNotOK, CurrentModuleObject);
-                if (IsNotOK) {
-                    ShowContinueError(state, format("specified in {} = \"{}\"", CurrentModuleObject, unitHeat.Name));
-                    ErrorsFound = true;
-                } else {
-                    // The heating coil control node is necessary for hot water and steam coils, but not necessary for an
-                    // electric or gas coil.
-                    if (unitHeat.Type == HCoilType::WaterHeatingCoil || unitHeat.Type == HCoilType::SteamCoil) {
-                        // mine the hot water or steam node from the coil object
-                        errFlag = false;
-                        if (unitHeat.Type == HCoilType::WaterHeatingCoil) {
-                            unitHeat.HotControlNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", unitHeat.HCoilName, errFlag);
-                        } else { // its a steam coil
-                            unitHeat.HCoil_Index = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", unitHeat.HCoilName, errFlag);
-                            unitHeat.HotControlNode = SteamCoils::GetCoilSteamInletNode(state, unitHeat.HCoil_Index, unitHeat.HCoilName, errFlag);
-                            unitHeat.HCoil_fluid = Fluid::GetSteam(state);
-                        }
-                        // Other error checks should trap before it gets to this point in the code, but including just in case.
-                        if (errFlag) {
-                            ShowContinueError(state, format("that was specified in {} = \"{}\"", CurrentModuleObject, unitHeat.Name));
-                            ErrorsFound = true;
-                        }
+                unitHeat.HeatCoilName = Alphas(8);
+                if (unitHeat.heatCoilType == HVAC::CoilType::HeatingWater) {
+                    unitHeat.HeatCoilNum = WaterCoils::GetCoilIndex(state, unitHeat.HeatCoilName);
+                    if (unitHeat.HeatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(8), unitHeat.HeatCoilName);
+                        ErrorsFound = true;
+                    } else {
+                        unitHeat.HotControlNode = WaterCoils::GetCoilWaterInletNode(state, unitHeat.HeatCoilNum);
+                    }
+                    
+                } else if (unitHeat.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                    unitHeat.HeatCoilNum = SteamCoils::GetCoilIndex(state, unitHeat.HeatCoilName);
+                    if (unitHeat.HeatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(8), unitHeat.HeatCoilName);
+                        ErrorsFound = true;
+                    } else {
+                        unitHeat.HotControlNode = SteamCoils::GetCoilSteamInletNode(state, unitHeat.HeatCoilNum);
+                        unitHeat.HeatCoilFluid = Fluid::GetSteam(state);
+                    }
+
+                } else if (unitHeat.heatCoilType == HVAC::CoilType::HeatingElectric ||
+                           unitHeat.heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel) {
+                    unitHeat.HeatCoilNum = HeatingCoils::GetCoilIndex(state, unitHeat.HeatCoilName);
+                    if (unitHeat.HeatCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, cAlphaFields(8), unitHeat.HeatCoilName);
+                        ErrorsFound = true;
                     }
                 }
             }
@@ -455,7 +459,7 @@ namespace UnitHeater {
                                        CurrentModuleObject,
                                        unitHeat.Name));
                 ShowContinueError(state, "..Zone exhaust node name is specified in ZoneHVAC:EquipmentConnections object.");
-                ShowContinueError(state, format("..Unit heater air inlet node name = {}", state.dataLoopNodes->NodeID(unitHeat.AirInNode)));
+                ShowContinueError(state, format("..Unit heater air inlet node name = {}", s_node->NodeID(unitHeat.AirInNode)));
                 ErrorsFound = true;
             }
             // check that unit heater air outlet node is a zone inlet node.
@@ -476,7 +480,7 @@ namespace UnitHeater {
                                        CurrentModuleObject,
                                        unitHeat.Name));
                 ShowContinueError(state, "..Zone inlet node name is specified in ZoneHVAC:EquipmentConnections object.");
-                ShowContinueError(state, format("..Unit heater air outlet node name = {}", state.dataLoopNodes->NodeID(unitHeat.AirOutNode)));
+                ShowContinueError(state, format("..Unit heater air outlet node name = {}", s_node->NodeID(unitHeat.AirOutNode)));
                 ErrorsFound = true;
             }
 
@@ -486,17 +490,17 @@ namespace UnitHeater {
                                                  unitHeat.Name,
                                                  HVAC::fanTypeNamesUC[(int)unitHeat.fanType],
                                                  unitHeat.FanName,
-                                                 state.dataLoopNodes->NodeID(unitHeat.AirInNode),
-                                                 state.dataLoopNodes->NodeID(unitHeat.FanOutletNode));
+                                                 s_node->NodeID(unitHeat.AirInNode),
+                                                 s_node->NodeID(unitHeat.FanOutletNode));
 
             // Add heating coil to component sets array
             BranchNodeConnections::SetUpCompSets(state,
                                                  CurrentModuleObject,
                                                  unitHeat.Name,
-                                                 unitHeat.HCoilTypeCh,
-                                                 unitHeat.HCoilName,
-                                                 state.dataLoopNodes->NodeID(unitHeat.FanOutletNode),
-                                                 state.dataLoopNodes->NodeID(unitHeat.AirOutNode));
+                                                 HVAC::coilTypeNames[(int)unitHeat.heatCoilType],
+                                                 unitHeat.HeatCoilName,
+                                                 s_node->NodeID(unitHeat.FanOutletNode),
+                                                 s_node->NodeID(unitHeat.AirOutNode));
 
         } // ...loop over all of the unit heaters found in the input file
 
@@ -557,8 +561,8 @@ namespace UnitHeater {
                                     OutputProcessor::StoreType::Average,
                                     unitHeat.Name);
             }
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-                state, unitHeat.HCoilName, unitHeat.HCoilTypeCh, unitHeat.FanName, unitHeat.fanType, unitHeat.Fan_Index);
+            ReportCoilSelection::setCoilSupplyFanInfo(
+                state, unitHeat.HeatCoilName, unitHeat.heatCoilType, unitHeat.FanName, unitHeat.fanType, unitHeat.Fan_Index);
         }
     }
 
@@ -592,6 +596,9 @@ namespace UnitHeater {
         Real64 SteamDensity;
         Real64 rho; // local fluid density
 
+        auto &s_node = state.dataLoopNodes;
+        
+        auto &unitHeat = state.dataUnitHeaters->UnitHeat(UnitHeatNum);
         // Do the one time initializations
         if (state.dataUnitHeaters->InitUnitHeaterOneTimeFlag) {
 
@@ -609,21 +616,21 @@ namespace UnitHeater {
         if (allocated(state.dataAvail->ZoneComp)) {
             auto &availMgr = state.dataAvail->ZoneComp(DataZoneEquipment::ZoneEquipType::UnitHeater).ZoneCompAvailMgrs(UnitHeatNum);
             if (state.dataUnitHeaters->MyZoneEqFlag(UnitHeatNum)) { // initialize the name of each availability manager list and zone number
-                availMgr.AvailManagerListName = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AvailManagerListName;
+                availMgr.AvailManagerListName = unitHeat.AvailManagerListName;
                 availMgr.ZoneNum = ZoneNum;
                 state.dataUnitHeaters->MyZoneEqFlag(UnitHeatNum) = false;
             }
-            state.dataUnitHeaters->UnitHeat(UnitHeatNum).availStatus = availMgr.availStatus;
+            unitHeat.availStatus = availMgr.availStatus;
         }
 
         if (state.dataUnitHeaters->MyPlantScanFlag(UnitHeatNum) && allocated(state.dataPlnt->PlantLoop)) {
-            if ((state.dataUnitHeaters->UnitHeat(UnitHeatNum).HeatingCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
-                (state.dataUnitHeaters->UnitHeat(UnitHeatNum).HeatingCoilType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
+            if ((unitHeat.HeatCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
+                (unitHeat.HeatCoilPlantType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
                 bool errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HeatingCoilType,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc,
+                                                        unitHeat.HeatCoilName,
+                                                        unitHeat.HeatCoilPlantType,
+                                                        unitHeat.HWplantLoc,
                                                         errFlag,
                                                         _,
                                                         _,
@@ -632,12 +639,12 @@ namespace UnitHeater {
                                                         _);
                 if (errFlag) {
                     ShowContinueError(state,
-                                      format("Reference Unit=\"{}\", type=ZoneHVAC:UnitHeater", state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name));
+                                      format("Reference Unit=\"{}\", type=ZoneHVAC:UnitHeater", unitHeat.Name));
                     ShowFatalError(state, "InitUnitHeater: Program terminated due to previous condition(s).");
                 }
 
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum =
-                    DataPlant::CompData::getPlantComponent(state, state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc).NodeNumOut;
+                unitHeat.HotCoilOutNodeNum =
+                    DataPlant::CompData::getPlantComponent(state, unitHeat.HWplantLoc).NodeNumOut;
             }
             state.dataUnitHeaters->MyPlantScanFlag(UnitHeatNum) = false;
         } else if (state.dataUnitHeaters->MyPlantScanFlag(UnitHeatNum) && !state.dataGlobal->AnyPlantInModel) {
@@ -664,45 +671,42 @@ namespace UnitHeater {
 
         if (state.dataGlobal->BeginEnvrnFlag && state.dataUnitHeaters->MyEnvrnFlag(UnitHeatNum) &&
             !state.dataUnitHeaters->MyPlantScanFlag(UnitHeatNum)) {
-            InNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode;
-            OutNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirOutNode;
+            InNode = unitHeat.AirInNode;
+            OutNode = unitHeat.AirOutNode;
             RhoAir = state.dataEnvrn->StdRhoAir;
 
             // set the mass flow rates from the input volume flow rates
-            state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow = RhoAir * state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirVolFlow;
+            unitHeat.MaxAirMassFlow = RhoAir * unitHeat.MaxAirVolFlow;
 
             // set the node max and min mass flow rates
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMax = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMin = 0.0;
+            s_node->Node(OutNode).MassFlowRateMax = unitHeat.MaxAirMassFlow;
+            s_node->Node(OutNode).MassFlowRateMin = 0.0;
 
-            state.dataLoopNodes->Node(InNode).MassFlowRateMax = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
+            s_node->Node(InNode).MassFlowRateMax = unitHeat.MaxAirMassFlow;
+            s_node->Node(InNode).MassFlowRateMin = 0.0;
 
-            if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::WaterHeatingCoil) {
-                rho = state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum)
-                          .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
+            if (unitHeat.heatCoilType == HVAC::CoilType::HeatingWater) {
+                rho = state.dataPlnt->PlantLoop(unitHeat.HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
 
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotWaterFlow = rho * state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow;
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).MinHotWaterFlow = rho * state.dataUnitHeaters->UnitHeat(UnitHeatNum).MinVolHotWaterFlow;
+                unitHeat.MaxHotWaterFlow = rho * unitHeat.MaxVolHotWaterFlow;
+                unitHeat.MinHotWaterFlow = rho * unitHeat.MinVolHotWaterFlow;
                 PlantUtilities::InitComponentNodes(state,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).MinHotWaterFlow,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotWaterFlow,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum);
+                                                   unitHeat.MinHotWaterFlow,
+                                                   unitHeat.MaxHotWaterFlow,
+                                                   unitHeat.HotControlNode,
+                                                   unitHeat.HotCoilOutNodeNum);
             }
-            if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::SteamCoil) {
+            if (unitHeat.heatCoilType == HVAC::CoilType::HeatingSteam) {
                 TempSteamIn = 100.00;
-                SteamDensity = state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_fluid->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotSteamFlow =
-                    SteamDensity * state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow;
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).MinHotSteamFlow =
-                    SteamDensity * state.dataUnitHeaters->UnitHeat(UnitHeatNum).MinVolHotSteamFlow;
+                SteamDensity = unitHeat.HeatCoilFluid->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
+                unitHeat.MaxHotSteamFlow = SteamDensity * unitHeat.MaxVolHotSteamFlow;
+                unitHeat.MinHotSteamFlow = SteamDensity * unitHeat.MinVolHotSteamFlow;
 
                 PlantUtilities::InitComponentNodes(state,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).MinHotSteamFlow,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotSteamFlow,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum);
+                                                   unitHeat.MinHotSteamFlow,
+                                                   unitHeat.MaxHotSteamFlow,
+                                                   unitHeat.HotControlNode,
+                                                   unitHeat.HotCoilOutNodeNum);
             }
 
             state.dataUnitHeaters->MyEnvrnFlag(UnitHeatNum) = false;
@@ -711,31 +715,30 @@ namespace UnitHeater {
         if (!state.dataGlobal->BeginEnvrnFlag) state.dataUnitHeaters->MyEnvrnFlag(UnitHeatNum) = true;
 
         // These initializations are done every iteration...
-        InNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode;
-        OutNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirOutNode;
+        InNode = unitHeat.AirInNode;
+        OutNode = unitHeat.AirOutNode;
 
         state.dataUnitHeaters->QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputReqToHeatSP; // zone load needed
-        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanOpModeSched != nullptr) {
-            if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanOpModeSched->getCurrentVal() == 0.0 &&
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanType == HVAC::FanType::OnOff) {
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanOp = HVAC::FanOp::Cycling;
+        if (unitHeat.fanOpModeSched != nullptr) {
+            if (unitHeat.fanOpModeSched->getCurrentVal() == 0.0 &&
+                unitHeat.fanType == HVAC::FanType::OnOff) {
+                unitHeat.fanOp = HVAC::FanOp::Cycling;
             } else {
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanOp = HVAC::FanOp::Continuous;
+                unitHeat.fanOp = HVAC::FanOp::Continuous;
             }
             if ((state.dataUnitHeaters->QZnReq < HVAC::SmallLoad) || state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
                 // Unit is available, but there is no load on it or we are in setback/deadband
-                if (!state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOffNoHeating &&
-                    state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanOpModeSched->getCurrentVal() > 0.0) {
-                    state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanOp = HVAC::FanOp::Continuous;
+                if (!unitHeat.FanOffNoHeating && unitHeat.fanOpModeSched->getCurrentVal() > 0.0) {
+                    unitHeat.fanOp = HVAC::FanOp::Continuous;
                 }
             }
         }
 
         state.dataUnitHeaters->SetMassFlowRateToZero = false;
-        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).availSched->getCurrentVal() > 0) {
-            if ((state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanAvailSched->getCurrentVal() > 0 || state.dataHVACGlobal->TurnFansOn) &&
+        if (unitHeat.availSched->getCurrentVal() > 0) {
+            if ((unitHeat.fanAvailSched->getCurrentVal() > 0 || state.dataHVACGlobal->TurnFansOn) &&
                 !state.dataHVACGlobal->TurnFansOff) {
-                if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOffNoHeating &&
+                if (unitHeat.FanOffNoHeating &&
                     ((state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputReqToHeatSP < HVAC::SmallLoad) ||
                      (state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)))) {
                     state.dataUnitHeaters->SetMassFlowRateToZero = true;
@@ -748,28 +751,28 @@ namespace UnitHeater {
         }
 
         if (state.dataUnitHeaters->SetMassFlowRateToZero) {
-            state.dataLoopNodes->Node(InNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMinAvail = 0.0;
-            state.dataLoopNodes->Node(OutNode).MassFlowRate = 0.0;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMaxAvail = 0.0;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMinAvail = 0.0;
+            s_node->Node(InNode).MassFlowRate = 0.0;
+            s_node->Node(InNode).MassFlowRateMaxAvail = 0.0;
+            s_node->Node(InNode).MassFlowRateMinAvail = 0.0;
+            s_node->Node(OutNode).MassFlowRate = 0.0;
+            s_node->Node(OutNode).MassFlowRateMaxAvail = 0.0;
+            s_node->Node(OutNode).MassFlowRateMinAvail = 0.0;
         } else {
-            state.dataLoopNodes->Node(InNode).MassFlowRate = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMaxAvail = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMinAvail = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
-            state.dataLoopNodes->Node(OutNode).MassFlowRate = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMaxAvail = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMinAvail = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirMassFlow;
+            s_node->Node(InNode).MassFlowRate = unitHeat.MaxAirMassFlow;
+            s_node->Node(InNode).MassFlowRateMaxAvail = unitHeat.MaxAirMassFlow;
+            s_node->Node(InNode).MassFlowRateMinAvail = unitHeat.MaxAirMassFlow;
+            s_node->Node(OutNode).MassFlowRate = unitHeat.MaxAirMassFlow;
+            s_node->Node(OutNode).MassFlowRateMaxAvail = unitHeat.MaxAirMassFlow;
+            s_node->Node(OutNode).MassFlowRateMinAvail = unitHeat.MaxAirMassFlow;
         }
 
         // Just in case the unit is off and conditions do not get sent through
         // the unit for some reason, set the outlet conditions equal to the inlet
         // conditions of the unit heater
-        state.dataLoopNodes->Node(OutNode).Temp = state.dataLoopNodes->Node(InNode).Temp;
-        state.dataLoopNodes->Node(OutNode).Press = state.dataLoopNodes->Node(InNode).Press;
-        state.dataLoopNodes->Node(OutNode).HumRat = state.dataLoopNodes->Node(InNode).HumRat;
-        state.dataLoopNodes->Node(OutNode).Enthalpy = state.dataLoopNodes->Node(InNode).Enthalpy;
+        s_node->Node(OutNode).Temp = s_node->Node(InNode).Temp;
+        s_node->Node(OutNode).Press = s_node->Node(InNode).Press;
+        s_node->Node(OutNode).HumRat = s_node->Node(InNode).HumRat;
+        s_node->Node(OutNode).Enthalpy = s_node->Node(InNode).Enthalpy;
     }
 
     void SizeUnitHeater(EnergyPlusData &state, int const UnitHeatNum)
@@ -818,21 +821,23 @@ namespace UnitHeater {
         Real64 MaxVolHotSteamFlowDes = 0.0;
         Real64 MaxVolHotSteamFlowUser = 0.0;
 
+        auto &unitHeat = state.dataUnitHeaters->UnitHeat(UnitHeatNum);
+        
         state.dataSize->DataScalableSizingON = false;
         state.dataSize->DataScalableCapSizingON = false;
         state.dataSize->ZoneHeatingOnlyFan = true;
         std::string CompType = "ZoneHVAC:UnitHeater";
-        std::string CompName = state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name;
-        state.dataSize->DataZoneNumber = state.dataUnitHeaters->UnitHeat(UnitHeatNum).ZonePtr;
-        state.dataSize->DataFanType = state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanType;
-        state.dataSize->DataFanIndex = state.dataUnitHeaters->UnitHeat(UnitHeatNum).Fan_Index;
+        std::string const &CompName = unitHeat.Name;
+        state.dataSize->DataZoneNumber = unitHeat.ZonePtr;
+        state.dataSize->DataFanType = unitHeat.fanType;
+        state.dataSize->DataFanIndex = unitHeat.Fan_Index;
         // unit heater is always blow thru
         state.dataSize->DataFanPlacement = HVAC::FanPlace::BlowThru;
 
         if (CurZoneEqNum > 0) {
             auto &ZoneEqSizing = state.dataSize->ZoneEqSizing(CurZoneEqNum);
-            if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).HVACSizingIndex > 0) {
-                zoneHVACIndex = state.dataUnitHeaters->UnitHeat(UnitHeatNum).HVACSizingIndex;
+            if (unitHeat.HVACSizingIndex > 0) {
+                zoneHVACIndex = unitHeat.HVACSizingIndex;
                 int SizingMethod = HVAC::HeatingAirflowSizing;
                 int FieldNum = 1; //  N1 , \field Maximum Supply Air Flow Rate
                 PrintFlag = true;
@@ -865,7 +870,7 @@ namespace UnitHeater {
                     sizingHeatingAirFlow.overrideSizingString(SizingString);
                     // sizingHeatingAirFlow.setHVACSizingIndexData(FanCoil(FanCoilNum).HVACSizingIndex);
                     sizingHeatingAirFlow.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
-                    state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
+                    unitHeat.MaxAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
 
                 } else if (SAFMethod == DataSizing::FlowPerHeatingCapacity) {
                     TempSize = DataSizing::AutoSize;
@@ -889,7 +894,7 @@ namespace UnitHeater {
                     sizingHeatingAirFlow.overrideSizingString(SizingString);
                     // sizingHeatingAirFlow.setHVACSizingIndexData(FanCoil(FanCoilNum).HVACSizingIndex);
                     sizingHeatingAirFlow.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
-                    state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
+                    unitHeat.MaxAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
                 }
                 state.dataSize->DataScalableSizingON = false;
             } else {
@@ -898,51 +903,49 @@ namespace UnitHeater {
                 int FieldNum = 1; // N1 , \field Maximum Supply Air Flow Rate
                 PrintFlag = true;
                 SizingString = state.dataUnitHeaters->UnitHeatNumericFields(UnitHeatNum).FieldNames(FieldNum) + " [m3/s]";
-                TempSize = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirVolFlow;
+                TempSize = unitHeat.MaxAirVolFlow;
                 bool errorsFound = false;
                 HeatingAirFlowSizer sizingHeatingAirFlow;
                 sizingHeatingAirFlow.overrideSizingString(SizingString);
                 // sizingHeatingAirFlow.setHVACSizingIndexData(FanCoil(FanCoilNum).HVACSizingIndex);
                 sizingHeatingAirFlow.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
+                unitHeat.MaxAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
             }
         }
 
         bool IsAutoSize = false;
-        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow == DataSizing::AutoSize) {
+        if (unitHeat.MaxVolHotWaterFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
 
-        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::WaterHeatingCoil) {
+        if (unitHeat.heatCoilType == HVAC::CoilType::HeatingWater) {
 
             if (CurZoneEqNum > 0) {
                 if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // Simulation continue
-                    if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow > 0.0) {
+                    if (unitHeat.MaxVolHotWaterFlow > 0.0) {
                         BaseSizer::reportSizerOutput(state,
                                                      "ZoneHVAC:UnitHeater",
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name,
+                                                     unitHeat.Name,
                                                      "User-Specified Maximum Hot Water Flow [m3/s]",
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow);
+                                                     unitHeat.MaxVolHotWaterFlow);
                     }
                 } else {
-                    CheckZoneSizing(state, "ZoneHVAC:UnitHeater", state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name);
+                    CheckZoneSizing(state, "ZoneHVAC:UnitHeater", unitHeat.Name);
+
+                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, unitHeat.HeatCoilNum);
+                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, unitHeat.HeatCoilNum);
 
-                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(
-                        state, "Coil:Heating:Water", state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName, ErrorsFound);
-                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(
-                        state, "Coil:Heating:Water", state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName, ErrorsFound);
                     if (IsAutoSize) {
                         bool DoWaterCoilSizing = false; // if TRUE do water coil sizing calculation
                         PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(state,
-                                                                           "Coil:Heating:Water",
-                                                                           state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
+                                                                           HVAC::coilTypeNames[(int)unitHeat.heatCoilType],
+                                                                           unitHeat.HeatCoilName,
                                                                            CoilWaterInletNode,
                                                                            CoilWaterOutletNode,
                                                                            ErrorsFound);
-                        int CoilNum = WaterCoils::GetWaterCoilIndex(
-                            state, "COIL:HEATING:WATER", state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName, ErrorsFound);
-                        if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) {
-                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp;
+                        
+                        if (state.dataWaterCoils->WaterCoil(unitHeat.HeatCoilNum).UseDesignWaterDeltaTemp) {
+                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(unitHeat.HeatCoilNum).DesignWaterDeltaTemp;
                             DoWaterCoilSizing = true;
                         } else {
                             if (PltSizHeatNum > 0) {
@@ -953,7 +956,7 @@ namespace UnitHeater {
                                 // If there is no heating Plant Sizing object and autosizing was requested, issue fatal error message
                                 ShowSevereError(state, "Autosizing of water coil requires a heating loop Sizing:Plant object");
                                 ShowContinueError(
-                                    state, format("Occurs in ZoneHVAC:UnitHeater Object={}", state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name));
+                                    state, format("Occurs in ZoneHVAC:UnitHeater Object={}", unitHeat.Name));
                                 ErrorsFound = true;
                             }
                         }
@@ -961,8 +964,8 @@ namespace UnitHeater {
                         if (DoWaterCoilSizing) {
                             auto &ZoneEqSizing = state.dataSize->ZoneEqSizing(CurZoneEqNum);
                             int SizingMethod = HVAC::HeatingCapacitySizing;
-                            if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).HVACSizingIndex > 0) {
-                                zoneHVACIndex = state.dataUnitHeaters->UnitHeat(UnitHeatNum).HVACSizingIndex;
+                            if (unitHeat.HVACSizingIndex > 0) {
+                                zoneHVACIndex = unitHeat.HVACSizingIndex;
                                 int CapSizingMethod = state.dataSize->ZoneHVACSizing(zoneHVACIndex).HeatingCapMethod;
                                 ZoneEqSizing.SizingMethod(SizingMethod) = CapSizingMethod;
                                 if (CapSizingMethod == DataSizing::HeatingDesignCapacity || CapSizingMethod == DataSizing::CapacityPerFloorArea ||
@@ -1008,27 +1011,27 @@ namespace UnitHeater {
                             }
 
                             if (DesCoilLoad >= HVAC::SmallLoad) {
-                                rho = state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum)
+                                rho = state.dataPlnt->PlantLoop(unitHeat.HWplantLoc.loopNum)
                                           .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
-                                Cp = state.dataPlnt->PlantLoop(state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum)
+                                Cp = state.dataPlnt->PlantLoop(unitHeat.HWplantLoc.loopNum)
                                          .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName);
                                 MaxVolHotWaterFlowDes = DesCoilLoad / (WaterCoilSizDeltaT * Cp * rho);
                             } else {
                                 MaxVolHotWaterFlowDes = 0.0;
                             }
                         }
-                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow = MaxVolHotWaterFlowDes;
+                        unitHeat.MaxVolHotWaterFlow = MaxVolHotWaterFlowDes;
                         BaseSizer::reportSizerOutput(state,
                                                      "ZoneHVAC:UnitHeater",
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name,
+                                                     unitHeat.Name,
                                                      "Design Size Maximum Hot Water Flow [m3/s]",
                                                      MaxVolHotWaterFlowDes);
                     } else {
-                        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow > 0.0 && MaxVolHotWaterFlowDes > 0.0) {
-                            MaxVolHotWaterFlowUser = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow;
+                        if (unitHeat.MaxVolHotWaterFlow > 0.0 && MaxVolHotWaterFlowDes > 0.0) {
+                            MaxVolHotWaterFlowUser = unitHeat.MaxVolHotWaterFlow;
                             BaseSizer::reportSizerOutput(state,
                                                          "ZoneHVAC:UnitHeater",
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name,
+                                                         unitHeat.Name,
                                                          "Design Size Maximum Hot Water Flow [m3/s]",
                                                          MaxVolHotWaterFlowDes,
                                                          "User-Specified Maximum Hot Water Flow [m3/s]",
@@ -1038,7 +1041,7 @@ namespace UnitHeater {
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
                                                 format("SizeUnitHeater: Potential issue with equipment sizing for ZoneHVAC:UnitHeater {}",
-                                                       state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name));
+                                                       unitHeat.Name));
                                     ShowContinueError(state,
                                                       format("User-Specified Maximum Hot Water Flow of {:.5R} [m3/s]", MaxVolHotWaterFlowUser));
                                     ShowContinueError(
@@ -1052,43 +1055,41 @@ namespace UnitHeater {
                 }
             }
         } else {
-            state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow = 0.0;
+            unitHeat.MaxVolHotWaterFlow = 0.0;
         }
 
         IsAutoSize = false;
-        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow == DataSizing::AutoSize) {
+        if (unitHeat.MaxVolHotSteamFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
 
-        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::SteamCoil) {
+        if (unitHeat.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
             if (CurZoneEqNum > 0) {
                 if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // Simulation continue
-                    if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow > 0.0) {
+                    if (unitHeat.MaxVolHotSteamFlow > 0.0) {
                         BaseSizer::reportSizerOutput(state,
                                                      "ZoneHVAC:UnitHeater",
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name,
+                                                     unitHeat.Name,
                                                      "User-Specified Maximum Steam Flow [m3/s]",
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow);
+                                                     unitHeat.MaxVolHotSteamFlow);
                     }
                 } else {
                     auto &ZoneEqSizing = state.dataSize->ZoneEqSizing(CurZoneEqNum);
-                    CheckZoneSizing(state, "ZoneHVAC:UnitHeater", state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name);
+                    CheckZoneSizing(state, "ZoneHVAC:UnitHeater", unitHeat.Name);
 
-                    int CoilSteamInletNode = SteamCoils::GetCoilSteamInletNode(
-                        state, "Coil:Heating:Steam", state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName, ErrorsFound);
-                    int CoilSteamOutletNode = SteamCoils::GetCoilSteamInletNode(
-                        state, "Coil:Heating:Steam", state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName, ErrorsFound);
+                    int CoilSteamInletNode = SteamCoils::GetCoilSteamInletNode(state, unitHeat.HeatCoilNum);
+                    int CoilSteamOutletNode = SteamCoils::GetCoilSteamInletNode(state, unitHeat.HeatCoilNum);
                     if (IsAutoSize) {
                         PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(state,
                                                                            "Coil:Heating:Steam",
-                                                                           state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
+                                                                           unitHeat.HeatCoilName,
                                                                            CoilSteamInletNode,
                                                                            CoilSteamOutletNode,
                                                                            ErrorsFound);
                         if (PltSizHeatNum > 0) {
-                            if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).HVACSizingIndex > 0) {
-                                zoneHVACIndex = state.dataUnitHeaters->UnitHeat(UnitHeatNum).HVACSizingIndex;
+                            if (unitHeat.HVACSizingIndex > 0) {
+                                zoneHVACIndex = unitHeat.HVACSizingIndex;
                                 int SizingMethod = HVAC::HeatingCapacitySizing;
                                 int CapSizingMethod = state.dataSize->ZoneHVACSizing(zoneHVACIndex).HeatingCapMethod;
                                 ZoneEqSizing.SizingMethod(SizingMethod) = CapSizingMethod;
@@ -1141,21 +1142,21 @@ namespace UnitHeater {
                         } else {
                             ShowSevereError(state, "Autosizing of Steam flow requires a heating loop Sizing:Plant object");
                             ShowContinueError(state,
-                                              format("Occurs in ZoneHVAC:UnitHeater Object={}", state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name));
+                                              format("Occurs in ZoneHVAC:UnitHeater Object={}", unitHeat.Name));
                             ErrorsFound = true;
                         }
-                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow = MaxVolHotSteamFlowDes;
+                        unitHeat.MaxVolHotSteamFlow = MaxVolHotSteamFlowDes;
                         BaseSizer::reportSizerOutput(state,
                                                      "ZoneHVAC:UnitHeater",
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name,
+                                                     unitHeat.Name,
                                                      "Design Size Maximum Steam Flow [m3/s]",
                                                      MaxVolHotSteamFlowDes);
                     } else {
-                        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow > 0.0 && MaxVolHotSteamFlowDes > 0.0) {
-                            MaxVolHotSteamFlowUser = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow;
+                        if (unitHeat.MaxVolHotSteamFlow > 0.0 && MaxVolHotSteamFlowDes > 0.0) {
+                            MaxVolHotSteamFlowUser = unitHeat.MaxVolHotSteamFlow;
                             BaseSizer::reportSizerOutput(state,
                                                          "ZoneHVAC:UnitHeater",
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name,
+                                                         unitHeat.Name,
                                                          "Design Size Maximum Steam Flow [m3/s]",
                                                          MaxVolHotSteamFlowDes,
                                                          "User-Specified Maximum Steam Flow [m3/s]",
@@ -1165,7 +1166,7 @@ namespace UnitHeater {
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
                                                 format("SizeUnitHeater: Potential issue with equipment sizing for ZoneHVAC:UnitHeater {}",
-                                                       state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name));
+                                                       unitHeat.Name));
                                     ShowContinueError(state, format("User-Specified Maximum Steam Flow of {:.5R} [m3/s]", MaxVolHotSteamFlowUser));
                                     ShowContinueError(state,
                                                       format("differs from Design Size Maximum Steam Flow of {:.5R} [m3/s]", MaxVolHotSteamFlowDes));
@@ -1178,19 +1179,19 @@ namespace UnitHeater {
                 }
             }
         } else {
-            state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotSteamFlow = 0.0;
+            unitHeat.MaxVolHotSteamFlow = 0.0;
         }
 
         // set the design air flow rate for the heating coil
-
-        WaterCoils::SetCoilDesFlow(state,
-                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilTypeCh,
-                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
-                                   state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxAirVolFlow,
-                                   ErrorsFound);
+        // This was previously applied to all coil types (I guess it just generated severe errors?)
+        // Why is this not applied to Steam and Heating coils?
+        if (unitHeat.heatCoilType == HVAC::CoilType::HeatingWater) {
+            WaterCoils::SetCoilDesFlow(state, unitHeat.HeatCoilNum, unitHeat.MaxAirVolFlow);
+        }
+        
         if (CurZoneEqNum > 0) {
             auto &ZoneEqSizing = state.dataSize->ZoneEqSizing(CurZoneEqNum);
-            ZoneEqSizing.MaxHWVolFlow = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxVolHotWaterFlow;
+            ZoneEqSizing.MaxHWVolFlow = unitHeat.MaxVolHotWaterFlow;
         }
 
         if (ErrorsFound) {
@@ -1254,65 +1255,66 @@ namespace UnitHeater {
         Real64 MaxWaterFlow = 0.0;
         Real64 MinWaterFlow = 0.0;
         Real64 PartLoadFrac = 0.0;
-        int InletNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode;
-        int OutletNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirOutNode;
-        int ControlNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode;
-        Real64 ControlOffset = state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlOffset;
-        HVAC::FanOp fanOp = state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanOp;
+
+        auto &s_node = state.dataLoopNodes;
+        auto &unitHeat = state.dataUnitHeaters->UnitHeat(UnitHeatNum);
+
+        Real64 ControlOffset = unitHeat.HotControlOffset;
+        HVAC::FanOp fanOp = unitHeat.fanOp;
 
         if (fanOp != HVAC::FanOp::Cycling) {
 
-            if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).availSched->getCurrentVal() <= 0 ||
-                ((state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanAvailSched->getCurrentVal() <= 0 && !state.dataHVACGlobal->TurnFansOn) ||
+            if (unitHeat.availSched->getCurrentVal() <= 0 ||
+                ((unitHeat.fanAvailSched->getCurrentVal() <= 0 && !state.dataHVACGlobal->TurnFansOn) ||
                  state.dataHVACGlobal->TurnFansOff)) {
                 // Case 1: OFF-->unit schedule says that it it not available
                 //         OR child fan in not available OR child fan not being cycled ON by sys avail manager
                 //         OR child fan being forced OFF by sys avail manager
                 state.dataUnitHeaters->HCoilOn = false;
-                if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::WaterHeatingCoil) {
+                if (unitHeat.heatCoilType == HVAC::CoilType::HeatingWater) {
                     mdot = 0.0; // try to turn off
 
                     PlantUtilities::SetComponentFlowRate(state,
                                                          mdot,
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
-                }
-                if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::SteamCoil) {
+                                                         unitHeat.HotControlNode,
+                                                         unitHeat.HotCoilOutNodeNum,
+                                                         unitHeat.HWplantLoc);
+
+                } else if (unitHeat.heatCoilType == HVAC::CoilType::HeatingSteam) {
                     mdot = 0.0; // try to turn off
 
                     PlantUtilities::SetComponentFlowRate(state,
                                                          mdot,
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                         state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
+                                                         unitHeat.HotControlNode,
+                                                         unitHeat.HotCoilOutNodeNum,
+                                                         unitHeat.HWplantLoc);
                 }
                 CalcUnitHeaterComponents(state, UnitHeatNum, FirstHVACIteration, QUnitOut);
 
             } else if ((state.dataUnitHeaters->QZnReq < HVAC::SmallLoad) || state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) {
                 // Unit is available, but there is no load on it or we are in setback/deadband
-                if (!state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOffNoHeating) {
+                if (!unitHeat.FanOffNoHeating) {
 
                     // Case 2: NO LOAD OR COOLING/ON-OFF FAN CONTROL-->turn everything off
                     //         because there is no load on the unit heater
                     state.dataUnitHeaters->HCoilOn = false;
-                    if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::WaterHeatingCoil) {
+                    if (unitHeat.heatCoilType == HVAC::CoilType::HeatingWater) {
                         mdot = 0.0; // try to turn off
 
                         PlantUtilities::SetComponentFlowRate(state,
                                                              mdot,
-                                                             state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                             state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                             state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
-                    }
-                    if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::SteamCoil) {
+                                                             unitHeat.HotControlNode,
+                                                             unitHeat.HotCoilOutNodeNum,
+                                                             unitHeat.HWplantLoc);
+
+                    } else if (unitHeat.heatCoilType == HVAC::CoilType::HeatingSteam) {
                         mdot = 0.0; // try to turn off
 
                         PlantUtilities::SetComponentFlowRate(state,
                                                              mdot,
-                                                             state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                             state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                             state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
+                                                             unitHeat.HotControlNode,
+                                                             unitHeat.HotCoilOutNodeNum,
+                                                             unitHeat.HWplantLoc);
                     }
                     CalcUnitHeaterComponents(state, UnitHeatNum, FirstHVACIteration, QUnitOut);
 
@@ -1323,25 +1325,25 @@ namespace UnitHeater {
                     // so there is really nothing else left to do except call the components.
 
                     state.dataUnitHeaters->HCoilOn = false;
-                    if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::WaterHeatingCoil) {
+                    if (unitHeat.heatCoilType == HVAC::CoilType::HeatingWater) {
                         mdot = 0.0; // try to turn off
 
-                        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum > 0) {
+                        if (unitHeat.HWplantLoc.loopNum > 0) {
                             PlantUtilities::SetComponentFlowRate(state,
                                                                  mdot,
-                                                                 state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                                 state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                                 state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
+                                                                 unitHeat.HotControlNode,
+                                                                 unitHeat.HotCoilOutNodeNum,
+                                                                 unitHeat.HWplantLoc);
                         }
-                    }
-                    if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type == HCoilType::SteamCoil) {
+
+                    } else if (unitHeat.heatCoilType == HVAC::CoilType::HeatingSteam) {
                         mdot = 0.0; // try to turn off
-                        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc.loopNum > 0) {
+                        if (unitHeat.HWplantLoc.loopNum > 0) {
                             PlantUtilities::SetComponentFlowRate(state,
                                                                  mdot,
-                                                                 state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                                 state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                                 state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
+                                                                 unitHeat.HotControlNode,
+                                                                 unitHeat.HotCoilOutNodeNum,
+                                                                 unitHeat.HWplantLoc);
                         }
                     }
 
@@ -1350,59 +1352,58 @@ namespace UnitHeater {
 
             } else { // Case 4: HEATING-->unit is available and there is a heating load
 
-                switch (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type) {
+                switch (unitHeat.heatCoilType) {
 
-                case HCoilType::WaterHeatingCoil: {
+                case HVAC::CoilType::HeatingWater: {
 
                     // On the first HVAC iteration the system values are given to the controller, but after that
                     // the demand limits are in place and there needs to be feedback to the Zone Equipment
                     if (FirstHVACIteration) {
-                        MaxWaterFlow = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotWaterFlow;
-                        MinWaterFlow = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MinHotWaterFlow;
+                        MaxWaterFlow = unitHeat.MaxHotWaterFlow;
+                        MinWaterFlow = unitHeat.MinHotWaterFlow;
                     } else {
-                        MaxWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMaxAvail;
-                        MinWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMinAvail;
+                        MaxWaterFlow = s_node->Node(unitHeat.HotControlNode).MassFlowRateMaxAvail;
+                        MinWaterFlow = s_node->Node(unitHeat.HotControlNode).MassFlowRateMinAvail;
                     }
                     // control water flow to obtain output matching QZnReq
                     ControlCompOutput(state,
-                                      state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name,
+                                      unitHeat.Name,
                                       state.dataUnitHeaters->cMO_UnitHeater,
                                       UnitHeatNum,
                                       FirstHVACIteration,
                                       state.dataUnitHeaters->QZnReq,
-                                      ControlNode,
+                                      unitHeat.HotControlNode,
                                       MaxWaterFlow,
                                       MinWaterFlow,
-                                      ControlOffset,
-                                      state.dataUnitHeaters->UnitHeat(UnitHeatNum).ControlCompTypeNum,
-                                      state.dataUnitHeaters->UnitHeat(UnitHeatNum).CompErrIndex,
+                                      unitHeat.HotControlOffset,
+                                      unitHeat.ControlCompTypeNum,
+                                      unitHeat.CompErrIndex,
                                       _,
                                       _,
                                       _,
                                       _,
                                       _,
-                                      state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
-                    break;
-                }
-                case HCoilType::Electric:
-                case HCoilType::Gas:
-                case HCoilType::SteamCoil: {
+                                      unitHeat.HWplantLoc);
+                } break;
+                  
+                case HVAC::CoilType::HeatingElectric:
+                case HVAC::CoilType::HeatingGasOrOtherFuel:
+                case HVAC::CoilType::HeatingSteam: {
                     state.dataUnitHeaters->HCoilOn = true;
                     CalcUnitHeaterComponents(state, UnitHeatNum, FirstHVACIteration, QUnitOut);
-                    break;
-                }
+                } break;
                 default:
                     break;
                 }
             }
-            if (state.dataLoopNodes->Node(InletNode).MassFlowRateMax > 0.0) {
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanPartLoadRatio =
-                    state.dataLoopNodes->Node(InletNode).MassFlowRate / state.dataLoopNodes->Node(InletNode).MassFlowRateMax;
+            if (s_node->Node(unitHeat.AirInNode).MassFlowRateMax > 0.0) {
+                unitHeat.FanPartLoadRatio =
+                    s_node->Node(unitHeat.AirInNode).MassFlowRate / s_node->Node(unitHeat.AirInNode).MassFlowRateMax;
             }
         } else { // OnOff fan and cycling
             if ((state.dataUnitHeaters->QZnReq < HVAC::SmallLoad) || (state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum)) ||
-                state.dataUnitHeaters->UnitHeat(UnitHeatNum).availSched->getCurrentVal() <= 0 ||
-                ((state.dataUnitHeaters->UnitHeat(UnitHeatNum).fanAvailSched->getCurrentVal() <= 0 && !state.dataHVACGlobal->TurnFansOn) ||
+                unitHeat.availSched->getCurrentVal() <= 0 ||
+                ((unitHeat.fanAvailSched->getCurrentVal() <= 0 && !state.dataHVACGlobal->TurnFansOn) ||
                  state.dataHVACGlobal->TurnFansOff)) {
                 // Case 1: OFF-->unit schedule says that it it not available
                 //         OR child fan in not available OR child fan not being cycled ON by sys avail manager
@@ -1411,9 +1412,9 @@ namespace UnitHeater {
                 state.dataUnitHeaters->HCoilOn = false;
                 CalcUnitHeaterComponents(state, UnitHeatNum, FirstHVACIteration, QUnitOut, fanOp, PartLoadFrac);
 
-                if (state.dataLoopNodes->Node(InletNode).MassFlowRateMax > 0.0) {
-                    state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanPartLoadRatio =
-                        state.dataLoopNodes->Node(InletNode).MassFlowRate / state.dataLoopNodes->Node(InletNode).MassFlowRateMax;
+                if (s_node->Node(unitHeat.AirInNode).MassFlowRateMax > 0.0) {
+                    unitHeat.FanPartLoadRatio =
+                        s_node->Node(unitHeat.AirInNode).MassFlowRate / s_node->Node(unitHeat.AirInNode).MassFlowRateMax;
                 }
 
             } else { // Case 4: HEATING-->unit is available and there is a heating load
@@ -1452,24 +1453,24 @@ namespace UnitHeater {
                 CalcUnitHeaterComponents(state, UnitHeatNum, FirstHVACIteration, QUnitOut, fanOp, PartLoadFrac);
 
             } // ...end of unit ON/OFF IF-THEN block
-            state.dataUnitHeaters->UnitHeat(UnitHeatNum).PartLoadFrac = PartLoadFrac;
-            state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanPartLoadRatio = PartLoadFrac;
-            state.dataLoopNodes->Node(OutletNode).MassFlowRate = state.dataLoopNodes->Node(InletNode).MassFlowRate;
+            unitHeat.PartLoadFrac = PartLoadFrac;
+            unitHeat.FanPartLoadRatio = PartLoadFrac;
+            s_node->Node(unitHeat.AirOutNode).MassFlowRate = s_node->Node(unitHeat.AirInNode).MassFlowRate;
         }
 
         // CR9155 Remove specific humidity calculations
-        SpecHumOut = state.dataLoopNodes->Node(OutletNode).HumRat;
-        SpecHumIn = state.dataLoopNodes->Node(InletNode).HumRat;
-        LatentOutput = state.dataLoopNodes->Node(OutletNode).MassFlowRate * (SpecHumOut - SpecHumIn); // Latent rate (kg/s), dehumid = negative
+        SpecHumOut = s_node->Node(unitHeat.AirOutNode).HumRat;
+        SpecHumIn = s_node->Node(unitHeat.AirInNode).HumRat;
+        LatentOutput = s_node->Node(unitHeat.AirOutNode).MassFlowRate * (SpecHumOut - SpecHumIn); // Latent rate (kg/s), dehumid = negative
 
-        QUnitOut = state.dataLoopNodes->Node(OutletNode).MassFlowRate *
-                   (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(OutletNode).Temp, state.dataLoopNodes->Node(InletNode).HumRat) -
-                    Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(InletNode).Temp, state.dataLoopNodes->Node(InletNode).HumRat));
+        QUnitOut = s_node->Node(unitHeat.AirOutNode).MassFlowRate *
+                   (Psychrometrics::PsyHFnTdbW(s_node->Node(unitHeat.AirOutNode).Temp, s_node->Node(unitHeat.AirInNode).HumRat) -
+                    Psychrometrics::PsyHFnTdbW(s_node->Node(unitHeat.AirInNode).Temp, s_node->Node(unitHeat.AirInNode).HumRat));
 
         // Report variables...
-        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HeatPower = max(0.0, QUnitOut);
-        state.dataUnitHeaters->UnitHeat(UnitHeatNum).ElecPower =
-            state.dataFans->fans(state.dataUnitHeaters->UnitHeat(UnitHeatNum).Fan_Index)->totalPower;
+        unitHeat.HeatPower = max(0.0, QUnitOut);
+        unitHeat.ElecPower =
+            state.dataFans->fans(unitHeat.Fan_Index)->totalPower;
 
         PowerMet = QUnitOut;
         LatOutputProvided = LatentOutput;
@@ -1501,165 +1502,146 @@ namespace UnitHeater {
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         Real64 AirMassFlow; // total mass flow through the unit
         Real64 CpAirZn;     // specific heat of dry air at zone conditions (zone conditions same as unit inlet)
-        int HCoilInAirNode; // inlet node number for fan exit/coil inlet
         Real64 mdot;        // local temporary for fluid mass flow rate
 
-        int InletNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode;
-        int OutletNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirOutNode;
+        auto &s_node = state.dataLoopNodes;
+        auto &unitHeat = state.dataUnitHeaters->UnitHeat(UnitHeatNum);
         Real64 QCoilReq = 0.0;
 
         if (fanOp != HVAC::FanOp::Cycling) {
-            state.dataFans->fans(state.dataUnitHeaters->UnitHeat(UnitHeatNum).Fan_Index)->simulate(state, FirstHVACIteration, _, _);
+            state.dataFans->fans(unitHeat.Fan_Index)->simulate(state, FirstHVACIteration, _, _);
 
-            switch (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type) {
+            switch (unitHeat.heatCoilType) {
 
-            case HCoilType::WaterHeatingCoil: {
-
-                WaterCoils::SimulateWaterCoilComponents(state,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
-                                                        FirstHVACIteration,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_Index);
-                break;
-            }
-            case HCoilType::SteamCoil: {
+            case HVAC::CoilType::HeatingWater: {
+                WaterCoils::SimulateWaterCoilComponents(state, unitHeat.HeatCoilName, FirstHVACIteration, unitHeat.HeatCoilNum);
+            } break;
+              
+            case HVAC::CoilType::HeatingSteam: {
 
                 if (!state.dataUnitHeaters->HCoilOn) {
                     QCoilReq = 0.0;
                 } else {
-                    HCoilInAirNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOutletNode;
-                    CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).HumRat);
+                    CpAirZn = Psychrometrics::PsyCpAirFnW(s_node->Node(unitHeat.AirInNode).HumRat);
                     QCoilReq =
-                        state.dataUnitHeaters->QZnReq - state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp -
-                                                             state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).Temp);
+                        state.dataUnitHeaters->QZnReq - s_node->Node(unitHeat.FanOutletNode).MassFlowRate * CpAirZn *
+                                                            (s_node->Node(unitHeat.FanOutletNode).Temp -
+                                                             s_node->Node(unitHeat.AirInNode).Temp);
                 }
                 if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
-                SteamCoils::SimulateSteamCoilComponents(state,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
-                                                        FirstHVACIteration,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_Index,
-                                                        QCoilReq);
-                break;
-            }
-            case HCoilType::Electric:
-            case HCoilType::Gas: {
+                SteamCoils::SimulateSteamCoilComponents(state, unitHeat.HeatCoilName, FirstHVACIteration, unitHeat.HeatCoilNum, QCoilReq);
+            } break;
+              
+            case HVAC::CoilType::HeatingElectric:
+            case HVAC::CoilType::HeatingGasOrOtherFuel: {
 
                 if (!state.dataUnitHeaters->HCoilOn) {
                     QCoilReq = 0.0;
                 } else {
-                    HCoilInAirNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOutletNode;
-                    CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).HumRat);
+                    CpAirZn = Psychrometrics::PsyCpAirFnW(s_node->Node(unitHeat.AirInNode).HumRat);
                     QCoilReq =
-                        state.dataUnitHeaters->QZnReq - state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp -
-                                                             state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).Temp);
+                        state.dataUnitHeaters->QZnReq - s_node->Node(unitHeat.FanOutletNode).MassFlowRate * CpAirZn *
+                                                            (s_node->Node(unitHeat.FanOutletNode).Temp -
+                                                             s_node->Node(unitHeat.AirInNode).Temp);
                 }
                 if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
-                HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                            state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
-                                                            FirstHVACIteration,
-                                                            QCoilReq,
-                                                            state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_Index);
-                break;
-            }
+                HeatingCoils::SimulateHeatingCoilComponents(state, unitHeat.HeatCoilName, FirstHVACIteration, QCoilReq, unitHeat.HeatCoilNum);
+            } break;
             default:
                 break;
             }
 
-            AirMassFlow = state.dataLoopNodes->Node(OutletNode).MassFlowRate;
+            AirMassFlow = s_node->Node(unitHeat.AirOutNode).MassFlowRate;
 
-            state.dataLoopNodes->Node(InletNode).MassFlowRate =
-                state.dataLoopNodes->Node(OutletNode).MassFlowRate; // maintain continuity through unit heater
+            s_node->Node(unitHeat.AirInNode).MassFlowRate =
+                s_node->Node(unitHeat.AirOutNode).MassFlowRate; // maintain continuity through unit heater
 
         } else { // OnOff fan cycling
 
-            state.dataLoopNodes->Node(InletNode).MassFlowRate = state.dataLoopNodes->Node(InletNode).MassFlowRateMax * PartLoadRatio;
-            AirMassFlow = state.dataLoopNodes->Node(InletNode).MassFlowRate;
+            s_node->Node(unitHeat.AirInNode).MassFlowRate = s_node->Node(unitHeat.AirInNode).MassFlowRateMax * PartLoadRatio;
+            AirMassFlow = s_node->Node(unitHeat.AirInNode).MassFlowRate;
             // Set the fan inlet node maximum available mass flow rates for cycling fans
-            state.dataLoopNodes->Node(InletNode).MassFlowRateMaxAvail = AirMassFlow;
+            s_node->Node(unitHeat.AirInNode).MassFlowRateMaxAvail = AirMassFlow;
 
             if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
-            state.dataFans->fans(state.dataUnitHeaters->UnitHeat(UnitHeatNum).Fan_Index)->simulate(state, FirstHVACIteration, _, _);
+            state.dataFans->fans(unitHeat.Fan_Index)->simulate(state, FirstHVACIteration, _, _);
 
-            switch (state.dataUnitHeaters->UnitHeat(UnitHeatNum).Type) {
+            switch (unitHeat.heatCoilType) {
 
-            case HCoilType::WaterHeatingCoil: {
+            case HVAC::CoilType::HeatingWater: {
 
                 if (!state.dataUnitHeaters->HCoilOn) {
                     mdot = 0.0;
                     QCoilReq = 0.0;
                 } else {
-                    HCoilInAirNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOutletNode;
-                    CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).HumRat);
+                    CpAirZn = Psychrometrics::PsyCpAirFnW(s_node->Node(unitHeat.AirInNode).HumRat);
                     QCoilReq =
-                        state.dataUnitHeaters->QZnReq - state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp -
-                                                             state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).Temp);
-                    mdot = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotWaterFlow * PartLoadRatio;
+                        state.dataUnitHeaters->QZnReq - s_node->Node(unitHeat.FanOutletNode).MassFlowRate * CpAirZn *
+                                                            (s_node->Node(unitHeat.FanOutletNode).Temp -
+                                                             s_node->Node(unitHeat.AirInNode).Temp);
+                    mdot = unitHeat.MaxHotWaterFlow * PartLoadRatio;
                 }
                 if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
                 PlantUtilities::SetComponentFlowRate(state,
                                                      mdot,
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
+                                                     unitHeat.HotControlNode,
+                                                     unitHeat.HotCoilOutNodeNum,
+                                                     unitHeat.HWplantLoc);
                 WaterCoils::SimulateWaterCoilComponents(state,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
+                                                        unitHeat.HeatCoilName,
                                                         FirstHVACIteration,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_Index,
+                                                        unitHeat.HeatCoilNum,
                                                         QCoilReq,
                                                         fanOp,
                                                         PartLoadRatio);
                 break;
             }
-            case HCoilType::SteamCoil: {
+            case HVAC::CoilType::HeatingSteam: {
                 if (!state.dataUnitHeaters->HCoilOn) {
                     mdot = 0.0;
                     QCoilReq = 0.0;
                 } else {
-                    HCoilInAirNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOutletNode;
-                    CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).HumRat);
+                    CpAirZn = Psychrometrics::PsyCpAirFnW(s_node->Node(unitHeat.AirInNode).HumRat);
                     QCoilReq =
-                        state.dataUnitHeaters->QZnReq - state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp -
-                                                             state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).Temp);
-                    mdot = state.dataUnitHeaters->UnitHeat(UnitHeatNum).MaxHotSteamFlow * PartLoadRatio;
+                        state.dataUnitHeaters->QZnReq - s_node->Node(unitHeat.FanOutletNode).MassFlowRate * CpAirZn *
+                                                            (s_node->Node(unitHeat.FanOutletNode).Temp -
+                                                             s_node->Node(unitHeat.AirInNode).Temp);
+                    mdot = unitHeat.MaxHotSteamFlow * PartLoadRatio;
                 }
                 if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
                 PlantUtilities::SetComponentFlowRate(state,
                                                      mdot,
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotControlNode,
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).HotCoilOutNodeNum,
-                                                     state.dataUnitHeaters->UnitHeat(UnitHeatNum).HWplantLoc);
+                                                     unitHeat.HotControlNode,
+                                                     unitHeat.HotCoilOutNodeNum,
+                                                     unitHeat.HWplantLoc);
                 SteamCoils::SimulateSteamCoilComponents(state,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
+                                                        unitHeat.HeatCoilName,
                                                         FirstHVACIteration,
-                                                        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_Index,
+                                                        unitHeat.HeatCoilNum,
                                                         QCoilReq,
                                                         _,
                                                         fanOp,
                                                         PartLoadRatio);
                 break;
             }
-            case HCoilType::Electric:
-            case HCoilType::Gas: {
+            case HVAC::CoilType::HeatingElectric:
+            case HVAC::CoilType::HeatingGasOrOtherFuel: {
 
                 if (!state.dataUnitHeaters->HCoilOn) {
                     QCoilReq = 0.0;
                 } else {
-                    HCoilInAirNode = state.dataUnitHeaters->UnitHeat(UnitHeatNum).FanOutletNode;
-                    CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).HumRat);
+                    CpAirZn = Psychrometrics::PsyCpAirFnW(s_node->Node(unitHeat.AirInNode).HumRat);
                     QCoilReq =
-                        state.dataUnitHeaters->QZnReq - state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp -
-                                                             state.dataLoopNodes->Node(state.dataUnitHeaters->UnitHeat(UnitHeatNum).AirInNode).Temp);
+                        state.dataUnitHeaters->QZnReq - s_node->Node(unitHeat.FanOutletNode).MassFlowRate * CpAirZn *
+                                                            (s_node->Node(unitHeat.FanOutletNode).Temp -
+                                                             s_node->Node(unitHeat.AirInNode).Temp);
                 }
                 if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
                 HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                            state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
+                                                            unitHeat.HeatCoilName,
                                                             FirstHVACIteration,
                                                             QCoilReq,
-                                                            state.dataUnitHeaters->UnitHeat(UnitHeatNum).HCoil_Index,
+                                                            unitHeat.HeatCoilNum,
                                                             _,
                                                             _,
                                                             fanOp,
@@ -1669,11 +1651,10 @@ namespace UnitHeater {
             default:
                 break;
             }
-            state.dataLoopNodes->Node(OutletNode).MassFlowRate =
-                state.dataLoopNodes->Node(InletNode).MassFlowRate; // maintain continuity through unit heater
+            s_node->Node(unitHeat.AirOutNode).MassFlowRate = s_node->Node(unitHeat.AirInNode).MassFlowRate; // maintain continuity through unit heater
         }
-        LoadMet = AirMassFlow * (Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(OutletNode).Temp, state.dataLoopNodes->Node(InletNode).HumRat) -
-                                 Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(InletNode).Temp, state.dataLoopNodes->Node(InletNode).HumRat));
+        LoadMet = AirMassFlow * (Psychrometrics::PsyHFnTdbW(s_node->Node(unitHeat.AirOutNode).Temp, s_node->Node(unitHeat.AirInNode).HumRat) -
+                                 Psychrometrics::PsyHFnTdbW(s_node->Node(unitHeat.AirInNode).Temp, s_node->Node(unitHeat.AirInNode).HumRat));
     }
 
     // SUBROUTINE UpdateUnitHeater
@@ -1699,12 +1680,14 @@ namespace UnitHeater {
         // Using/Aliasing
         Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
 
-        state.dataUnitHeaters->UnitHeat(UnitHeatNum).HeatEnergy = state.dataUnitHeaters->UnitHeat(UnitHeatNum).HeatPower * TimeStepSysSec;
-        state.dataUnitHeaters->UnitHeat(UnitHeatNum).ElecEnergy = state.dataUnitHeaters->UnitHeat(UnitHeatNum).ElecPower * TimeStepSysSec;
+        auto &unitHeat = state.dataUnitHeaters->UnitHeat(UnitHeatNum);
+        
+        unitHeat.HeatEnergy = unitHeat.HeatPower * TimeStepSysSec;
+        unitHeat.ElecEnergy = unitHeat.ElecPower * TimeStepSysSec;
 
-        if (state.dataUnitHeaters->UnitHeat(UnitHeatNum).FirstPass) { // reset sizing flags so other zone equipment can size normally
+        if (unitHeat.FirstPass) { // reset sizing flags so other zone equipment can size normally
             if (!state.dataGlobal->SysSizingCalc) {
-                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, 0, state.dataUnitHeaters->UnitHeat(UnitHeatNum).FirstPass);
+                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, 0, unitHeat.FirstPass);
             }
         }
     }
diff --git a/src/EnergyPlus/UnitHeater.hh b/src/EnergyPlus/UnitHeater.hh
index e5b59080522..5b9d81048b4 100644
--- a/src/EnergyPlus/UnitHeater.hh
+++ b/src/EnergyPlus/UnitHeater.hh
@@ -65,33 +65,19 @@ struct EnergyPlusData;
 
 namespace UnitHeater {
 
-    enum class HCoilType
-    {
-        Invalid = -1,
-        Electric,
-        Gas,
-        WaterHeatingCoil,
-        SteamCoil,
-        Num
-    };
-
-    static constexpr std::array<std::string_view, static_cast<int>(HCoilType::Num)> HCoilTypeNamesUC{
-        "COIL:HEATING:ELECTRIC",
-        "COIL:HEATING:FUEL",
-        "COIL:HEATING:WATER",
-        "COIL:HEATING:STEAM",
-    };
-
     struct UnitHeaterData
     {
         // Members
         // Input data
-        std::string Name;                      // name of unit
+
+        std::string Name;      // name of unit
         Sched::Schedule *availSched = nullptr; // availability schedule
-        int AirInNode;                         // inlet air node number
-        int AirOutNode;                        // outlet air node number
-        HVAC::FanType fanType;                 // Fan type number (see DataHVACGlobals)
-        std::string FanName;                   // name of fan
+
+        int AirInNode = 0;         // inlet air node number
+        int AirOutNode = 0;        // outlet air node number
+
+        HVAC::FanType fanType; // Fan type number (see DataHVACGlobals)
+        std::string FanName;   // name of fan
         int Fan_Index;
         Sched::Schedule *fanOpModeSched = nullptr; // fan operating mode schedule
         Sched::Schedule *fanAvailSched = nullptr;  // fan availability schedule
@@ -103,12 +89,13 @@ namespace UnitHeater {
         int FanOutletNode;                      // outlet node number for fan exit
         // (assumes fan is upstream of heating coil)
         HVAC::FanOp fanOp = HVAC::FanOp::Invalid; // mode of operation; 1=cycling fan, cycling coil, 2=continuous fan, cycling coil
-        HCoilType Type;                           // type of heating coil (water, gas, electric, etc.)
-        std::string HCoilTypeCh;                  // actual object name
-        std::string HCoilName;                    // name of heating coil
-        int HCoil_Index;
-        DataPlant::PlantEquipmentType HeatingCoilType;
-        Fluid::RefrigProps *HCoil_fluid = nullptr;
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;                           // type of heating coil (water, gas, electric, etc.)
+
+        std::string HeatCoilName;                    // name of heating coil
+        int HeatCoilNum = 0;
+        DataPlant::PlantEquipmentType HeatCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+        Fluid::RefrigProps *HeatCoilFluid = nullptr;
+      
         Real64 MaxVolHotWaterFlow; // m3/s
         Real64 MaxVolHotSteamFlow; // m3/s
         Real64 MaxHotWaterFlow;    // kg/s
@@ -117,8 +104,8 @@ namespace UnitHeater {
         Real64 MinVolHotSteamFlow; // m3/s
         Real64 MinHotWaterFlow;    // kg/s
         Real64 MinHotSteamFlow;    // kg/s
-        int HotControlNode;        // hot water control node, inlet of coil
-        Real64 HotControlOffset;   // control tolerance
+        int HotControlNode = 0.0;        // hot water control node, inlet of coil
+        Real64 HotControlOffset = 0.0;   // control tolerance
         int HotCoilOutNodeNum;     // outlet of coil
         PlantLocation HWplantLoc;  // Location of plant component for hot plant coil
         Real64 PartLoadFrac;       // part load fraction for the unit
@@ -137,12 +124,12 @@ namespace UnitHeater {
 
         // Default Constructor
         UnitHeaterData()
-            : AirInNode(0), AirOutNode(0), fanType(HVAC::FanType::Invalid), Fan_Index(0), ControlCompTypeNum(0), CompErrIndex(0), MaxAirVolFlow(0.0),
-              MaxAirMassFlow(0.0), FanOutletNode(0), HCoil_Index(0), HeatingCoilType(DataPlant::PlantEquipmentType::Invalid), MaxVolHotWaterFlow(0.0),
-              MaxVolHotSteamFlow(0.0), MaxHotWaterFlow(0.0), MaxHotSteamFlow(0.0), MinVolHotWaterFlow(0.0), MinVolHotSteamFlow(0.0),
-              MinHotWaterFlow(0.0), MinHotSteamFlow(0.0), HotControlNode(0), HotControlOffset(0.0), HotCoilOutNodeNum(0), HWplantLoc{},
-              PartLoadFrac(0.0), HeatPower(0.0), HeatEnergy(0.0), ElecPower(0.0), ElecEnergy(0.0), FanOffNoHeating(false), FanPartLoadRatio(0.0),
-              ZonePtr(0), HVACSizingIndex(0), FirstPass(true)
+            : fanType(HVAC::FanType::Invalid), Fan_Index(0), 
+              ControlCompTypeNum(0), CompErrIndex(0), MaxAirVolFlow(0.0), MaxAirMassFlow(0.0), FanOutletNode(0), 
+              MaxVolHotWaterFlow(0.0), MaxVolHotSteamFlow(0.0), MaxHotWaterFlow(0.0),
+              MaxHotSteamFlow(0.0), MinVolHotWaterFlow(0.0), MinVolHotSteamFlow(0.0), MinHotWaterFlow(0.0), MinHotSteamFlow(0.0), HotControlNode(0),
+              HotControlOffset(0.0), HotCoilOutNodeNum(0), HWplantLoc{}, PartLoadFrac(0.0), HeatPower(0.0), HeatEnergy(0.0), ElecPower(0.0),
+              ElecEnergy(0.0), FanOffNoHeating(false), FanPartLoadRatio(0.0), ZonePtr(0), HVACSizingIndex(0), FirstPass(true)
         {
         }
     };
diff --git a/src/EnergyPlus/UnitVentilator.cc b/src/EnergyPlus/UnitVentilator.cc
index f27c5ae09c6..63ba31bccbf 100644
--- a/src/EnergyPlus/UnitVentilator.cc
+++ b/src/EnergyPlus/UnitVentilator.cc
@@ -119,10 +119,6 @@ namespace UnitVentilator {
         "NONE", "HEATINGANDCOOLING", "HEATING", "COOLING"};
     static constexpr std::array<std::string_view, static_cast<int>(OAControl::Num)> OAControlNamesUC = {
         "VARIABLEPERCENT", "FIXEDTEMPERATURE", "FIXEDAMOUNT"};
-    static constexpr std::array<std::string_view, static_cast<int>(HeatCoilType::Num)> HeatCoilTypeNamesUC = {
-        "COIL:HEATING:ELECTRIC", "COIL:HEATING:FUEL", "COIL:HEATING:WATER", "COIL:HEATING:STEAM"};
-    static constexpr std::array<std::string_view, static_cast<int>(CoolCoilType::Num)> CoolCoilTypeNamesUC = {
-        "COIL:COOLING:WATER", "COIL:COOLING:WATER:DETAILEDGEOMETRY", "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED"};
 
     void SimUnitVentilator(EnergyPlusData &state,
                            std::string_view CompName,     // name of the fan coil unit
@@ -218,8 +214,6 @@ namespace UnitVentilator {
         int NumNumbers;                // Number of Numbers for each GetObjectItem call
         bool IsValid;                  // Set for outside air node check
         bool errFlag(false);           // interim error flag
-        std::string cCoolingCoilType;  // Cooling coil object type
-        std::string cHeatingCoilType;  // Heating coil object type
         Real64 FanVolFlow;             // volumetric flow rate of fan
         Array1D_string Alphas;         // Alpha items for object
         Array1D<Real64> Numbers;       // Numeric items for object
@@ -231,7 +225,7 @@ namespace UnitVentilator {
 
         // Figure out how many unit ventilators there are in the input file
 
-        std::string CurrentModuleObject = state.dataUnitVentilators->cMO_UnitVentilator;
+        std::string CurrentModuleObject = std::string{CMO_UnitVentilator};
         state.dataUnitVentilators->NumOfUnitVents = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, CurrentModuleObject);
         state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, CurrentModuleObject, NumFields, NumAlphas, NumNumbers);
 
@@ -297,8 +291,6 @@ namespace UnitVentilator {
             }
 
             unitVent.OutAirVolFlow = Numbers(3);
-            cCoolingCoilType = "";
-            cHeatingCoilType = "";
 
             unitVent.OAControlType = static_cast<OAControl>(getEnumValue(OAControlNamesUC, Alphas(3)));
             switch (unitVent.OAControlType) {
@@ -541,7 +533,7 @@ namespace UnitVentilator {
                 }
             }
 
-            unitVent.CoilOption = (CoilsUsed)getEnumValue(CoilsUsedNamesUC, Alphas(13));
+            unitVent.CoilOption = static_cast<CoilsUsed>(getEnumValue(CoilsUsedNamesUC, Alphas(13)));
 
             if (lAlphaBlanks(14)) {
                 unitVent.fanOp = (unitVent.fanType == HVAC::FanType::OnOff || unitVent.fanType == HVAC::FanType::SystemModel)
@@ -559,43 +551,51 @@ namespace UnitVentilator {
             // Get Coil information
             if (unitVent.CoilOption == CoilsUsed::Both || unitVent.CoilOption == CoilsUsed::Heating) {
                 if ((!lAlphaBlanks(16))) {
-                    unitVent.HCoilPresent = true;
-                    cHeatingCoilType = Alphas(15);
-                    unitVent.HCoilTypeCh = cHeatingCoilType;
-                    unitVent.HCoilType = (HeatCoilType)getEnumValue(HeatCoilTypeNamesUC, cHeatingCoilType);
-                    unitVent.HeatingCoilType = (DataPlant::PlantEquipmentType)getEnumValue(DataPlant::PlantEquipTypeNamesUC, cHeatingCoilType);
-
-                    unitVent.HCoilName = Alphas(16);
-                    ValidateComponent(state, cHeatingCoilType, unitVent.HCoilName, IsNotOK, CurrentModuleObject);
-                    if (IsNotOK) {
-                        ShowContinueError(state, format("...specified in {} = \"{}\".", CurrentModuleObject, unitVent.Name));
-                        ErrorsFound = true;
-                    } else {
-                        // The heating coil control node is necessary for a hot water coil, but not necessary for electric or gas.
-                        if (unitVent.HCoilType == HeatCoilType::Water || unitVent.HCoilType == HeatCoilType::Steam) {
-                            // mine the hot water or steam node from the coil object
-                            if (unitVent.HCoilType == HeatCoilType::Water) {
-                                unitVent.HCoil_Index = WaterCoils::GetCompIndex(state, WaterCoils::CoilModel::HeatingSimple, unitVent.HCoilName);
-                                unitVent.HotControlNode = state.dataWaterCoils->WaterCoil(unitVent.HCoil_Index).WaterInletNodeNum;
-                                unitVent.MaxVolHotWaterFlow = state.dataWaterCoils->WaterCoil(unitVent.HCoil_Index).MaxWaterVolFlowRate;
-                                // Could probably remove MaxVolHotSteamFlow here
-                                unitVent.MaxVolHotSteamFlow = unitVent.MaxVolHotWaterFlow;
-                            } else {
-                                unitVent.HCoil_Index = SteamCoils::GetCompIndex(state, unitVent.HCoilName);
-                                unitVent.HotControlNode = state.dataSteamCoils->SteamCoil(unitVent.HCoil_Index).SteamInletNodeNum;
-                                // Could probably replace MaxVolHotWaterFlow here with MaxVolHotSteamFlow
-                                unitVent.MaxVolHotWaterFlow = state.dataSteamCoils->SteamCoil(unitVent.HCoil_Index).MaxSteamVolFlowRate;
-                                // unitVent.MaxVolHotWaterFlow =
-                                //    SteamCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Steam", unitVent.HCoilName, ErrorsFound);
-                                unitVent.MaxVolHotSteamFlow = unitVent.MaxVolHotWaterFlow;
-                            }
+                    unitVent.HeatCoilPresent = true;
+                    unitVent.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(15)));
+                    unitVent.HeatCoilPlantType = static_cast<DataPlant::PlantEquipmentType>(getEnumValue(DataPlant::PlantEquipTypeNamesUC, Alphas(15)));
+
+                    unitVent.HeatCoilName = Alphas(16);
+                    if (unitVent.heatCoilType == HVAC::CoilType::HeatingWater) {
+                        unitVent.HeatCoilNum = WaterCoils::GetCoilIndex(state, unitVent.HeatCoilName);
+                        if (unitVent.HeatCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(16), unitVent.HeatCoilName);
+                            ErrorsFound = true;
+                        } else {
+                            unitVent.HeatCoilControlNodeNum = WaterCoils::GetCoilWaterInletNode(state, unitVent.HeatCoilNum);
+                            unitVent.HeatCoilWaterOutNodeNum = WaterCoils::GetCoilWaterOutletNode(state, unitVent.HeatCoilNum);
+                            unitVent.MaxVolHotWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, unitVent.HeatCoilNum);
+                            // Could probably remove MaxVolHotSteamFlow here
+                            unitVent.MaxVolHotSteamFlow = unitVent.MaxVolHotWaterFlow;
+                        }
+
+                    } else if (unitVent.heatCoilType == HVAC::CoilType::HeatingSteam) {
+                        unitVent.HeatCoilNum = SteamCoils::GetCoilIndex(state, unitVent.HeatCoilName);
+                        if (unitVent.HeatCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(16), unitVent.HeatCoilName);
+                            ErrorsFound = true;
+                        } else { 
+                            unitVent.HeatCoilControlNodeNum = SteamCoils::GetCoilSteamInletNode(state, unitVent.HeatCoilNum);
+                            // Could probably replace MaxVolHotWaterFlow here with MaxVolHotSteamFlow
+                            unitVent.MaxVolHotWaterFlow = SteamCoils::GetCoilMaxWaterFlowRate(state, unitVent.HeatCoilNum);
+                            // unitVent.MaxVolHotWaterFlow =
+                            //    SteamCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Steam", unitVent.HCoilName, ErrorsFound);
+                            unitVent.MaxVolHotSteamFlow = unitVent.MaxVolHotWaterFlow;
+                        }
+                        
+                    } else if (unitVent.heatCoilType == HVAC::CoilType::HeatingElectric ||
+                               unitVent.heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel) {
+                        unitVent.HeatCoilNum = HeatingCoils::GetCoilIndex(state, unitVent.HeatCoilName);
+                        if (unitVent.HeatCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(16), unitVent.HeatCoilName);
+                            ErrorsFound = true;
                         }
                     }
 
-                    unitVent.HotControlOffset = Numbers(4);
+                    unitVent.HeatCoilControlOffset = Numbers(4);
                     // Set default convergence tolerance
-                    if (unitVent.HotControlOffset <= 0.0) {
-                        unitVent.HotControlOffset = 0.001;
+                    if (unitVent.HeatCoilControlOffset <= 0.0) {
+                        unitVent.HeatCoilControlOffset = 0.001;
                     }
                 } else { // heating coil is required for these options
                     ShowSevereError(state, format("{}{}=\"{}\".", RoutineName, CurrentModuleObject, unitVent.Name));
@@ -606,68 +606,48 @@ namespace UnitVentilator {
 
             if (unitVent.CoilOption == CoilsUsed::Both || unitVent.CoilOption == CoilsUsed::Cooling) {
                 if (!lAlphaBlanks(18)) {
-                    unitVent.CCoilPresent = true;
+                    unitVent.CoolCoilPresent = true;
                     errFlag = false;
 
-                    cCoolingCoilType = Alphas(17);
-                    unitVent.CCoilTypeCh = cCoolingCoilType;
-                    unitVent.CCoilType = (CoolCoilType)getEnumValue(CoolCoilTypeNamesUC, cCoolingCoilType);
-                    unitVent.CoolingCoilType = (DataPlant::PlantEquipmentType)getEnumValue(DataPlant::PlantEquipTypeNamesUC, cCoolingCoilType);
-                    unitVent.CCoilPlantName = Alphas(18);
-
-                    if (cCoolingCoilType == "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED") {
-                        unitVent.CCoilType = CoolCoilType::HXAssisted;
-                        HVACHXAssistedCoolingCoil::GetHXCoilTypeAndName(
-                            state, cCoolingCoilType, Alphas(18), ErrorsFound, unitVent.CCoilPlantType, unitVent.CCoilPlantName);
-                        if (Util::SameString(unitVent.CCoilPlantType, "Coil:Cooling:Water")) {
-                            unitVent.CoolingCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                        } else if (Util::SameString(unitVent.CCoilPlantType, "Coil:Cooling:Water:DetailedGeometry")) {
-                            unitVent.CoolingCoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
-                        } else {
-                            ShowSevereError(state, format("{}{}=\"{}\".", RoutineName, CurrentModuleObject, unitVent.Name));
-                            ShowContinueError(state, format("For: {}=\"{}\".", cAlphaFields(17), Alphas(17)));
-                            ShowContinueError(state, format("Invalid Coil Type={}, Name={}", unitVent.CCoilPlantType, unitVent.CCoilPlantName));
-                            ShowContinueError(state,
-                                              "must be \"Coil:Cooling:Water\", \"Coil:Cooling:Water:DetailedGeometry\" or, "
-                                              "\"CoilSystem:Cooling:Water:HeatExchangerAssisted\".");
-                            errFlag = true;
+                    unitVent.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(17)));
+                    unitVent.CoolCoilPlantType = static_cast<DataPlant::PlantEquipmentType>(getEnumValue(DataPlant::PlantEquipTypeNamesUC, Alphas(17)));
+                    unitVent.CoolCoilName = Alphas(18);
+
+                    if (unitVent.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                        unitVent.CoolCoilNum = HXAssistCoil::GetCoilIndex(state, unitVent.CoolCoilName);
+                        if (unitVent.CoolCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(18), unitVent.HeatCoilName);
                             ErrorsFound = true;
+                        } else {
+                            unitVent.ChildCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, unitVent.CoolCoilNum);
+                            unitVent.ChildCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, unitVent.CoolCoilNum);
+                            unitVent.ChildCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(state, unitVent.CoolCoilNum);
+                            // special case, call the parent and return the child water inlet node and water volume flow rate
+                            unitVent.CoolCoilControlNodeNum = HXAssistCoil::GetCoilWaterInletNode(state, unitVent.CoolCoilNum);
+                            unitVent.MaxVolColdWaterFlow = HXAssistCoil::GetCoilMaxWaterFlowRate(state, unitVent.CoolCoilNum);
                         }
-                    }
 
-                    if (!errFlag) {
-                        unitVent.CCoilName = Alphas(18);
-                        ValidateComponent(state, cCoolingCoilType, unitVent.CCoilName, IsNotOK, CurrentModuleObject);
-                        if (IsNotOK) {
-                            ShowContinueError(state, format("...specified in {} = \"{}\".", CurrentModuleObject, unitVent.Name));
+                    } else if (unitVent.coolCoilType == HVAC::CoilType::CoolingWater) {
+                        unitVent.CoolCoilNum = WaterCoils::GetCoilIndex(state, unitVent.CoolCoilName);  
+                        if (unitVent.CoolCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(18), unitVent.HeatCoilName);
                             ErrorsFound = true;
                         } else {
-                            if (unitVent.CCoilType != CoolCoilType::HXAssisted) {
-                                WaterCoils::CoilModel coilModel = WaterCoils::CoilModel::CoolingSimple;
-                                if (unitVent.CCoilType == CoolCoilType::Detailed) coilModel = WaterCoils::CoilModel::CoolingDetailed;
-                                unitVent.CCoil_Index = WaterCoils::GetCompIndex(state, coilModel, unitVent.CCoilName);
-                                unitVent.ColdControlNode = state.dataWaterCoils->WaterCoil(unitVent.CCoil_Index).WaterInletNodeNum;
-                                unitVent.MaxVolColdWaterFlow = state.dataWaterCoils->WaterCoil(unitVent.CCoil_Index).MaxWaterVolFlowRate;
-                            } else {
-                                // special case, call the parent and return the child water inlet node and water volume flow rate
-                                unitVent.ColdControlNode =
-                                    HVACHXAssistedCoolingCoil::GetCoilWaterInletNode(state, unitVent.CCoilTypeCh, unitVent.CCoilName, errFlag);
-                                unitVent.MaxVolColdWaterFlow = HVACHXAssistedCoolingCoil::GetCoilMaxWaterFlowRate(
-                                    state, "CoilSystem:Cooling:Water:HeatExchangerAssisted", unitVent.CCoilName, errFlag);
-                            }
-                            // Other error checks should trap before it gets to this point in the code, but including just in case.
-                            if (errFlag) {
-                                ShowContinueError(state, format("...specified in {} = \"{}\".", CurrentModuleObject, unitVent.Name));
-                                ErrorsFound = true;
-                            }
+#ifdef GET_OUT
+                            // Not sure what to do with this
+                            WaterCoils::CoilModel coilModel = WaterCoils::CoilModel::CoolingSimple;
+                            if (unitVent.CCoilType == CoolCoilType::Detailed) coilModel = WaterCoils::CoilModel::CoolingDetailed;
+#endif // GET_OUT                                
+                            unitVent.CoolCoilControlNodeNum = WaterCoils::GetCoilWaterInletNode(state, unitVent.CoolCoilNum);
+                            unitVent.MaxVolColdWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, unitVent.CoolCoilNum);
                         }
                     }
 
                     unitVent.MinVolColdWaterFlow = 0.0;
-                    unitVent.ColdControlOffset = Numbers(5);
+                    unitVent.CoolCoilControlOffset = Numbers(5);
                     // Set default convergence tolerance
-                    if (unitVent.ColdControlOffset <= 0.0) {
-                        unitVent.ColdControlOffset = 0.001;
+                    if (unitVent.CoolCoilControlOffset <= 0.0) {
+                        unitVent.CoolCoilControlOffset = 0.001;
                     }
                 } else { // Cooling Coil is required for this/these options
                     ShowSevereError(state, format("{}{}=\"{}\".", RoutineName, CurrentModuleObject, unitVent.Name));
@@ -675,6 +655,7 @@ namespace UnitVentilator {
                     ErrorsFound = true;
                 } // IF (.NOT. lAlphaBlanks(17)) THEN - from the start of cooling coil information
             }
+            
             if (!unitVent.ATMixerExists) {
                 // check that unit ventilator air inlet node is the same as a zone exhaust node
                 ZoneNodeNotFound = true;
@@ -828,8 +809,8 @@ namespace UnitVentilator {
                     BranchNodeConnections::SetUpCompSets(state,
                                                          CurrentModuleObject,
                                                          unitVent.Name,
-                                                         cCoolingCoilType,
-                                                         unitVent.CCoilName,
+                                                         HVAC::coilTypeNames[(int)unitVent.coolCoilType],
+                                                         unitVent.CoolCoilName,
                                                          state.dataLoopNodes->NodeID(unitVent.FanOutletNode),
                                                          "UNDEFINED");
 
@@ -837,18 +818,19 @@ namespace UnitVentilator {
                     BranchNodeConnections::SetUpCompSets(state,
                                                          CurrentModuleObject,
                                                          unitVent.Name,
-                                                         cHeatingCoilType,
-                                                         unitVent.HCoilName,
+                                                         HVAC::coilTypeNames[(int)unitVent.heatCoilType],
+                                                         unitVent.HeatCoilName,
                                                          "UNDEFINED",
                                                          state.dataLoopNodes->NodeID(unitVent.AirOutNode));
                 } break;
+                  
                 case CoilsUsed::Heating: {
                     // Add heating coil to component sets array when no cooling coil present
                     BranchNodeConnections::SetUpCompSets(state,
                                                          CurrentModuleObject,
                                                          unitVent.Name,
-                                                         cHeatingCoilType,
-                                                         unitVent.HCoilName,
+                                                         HVAC::coilTypeNames[(int)unitVent.heatCoilType],
+                                                         unitVent.HeatCoilName,
                                                          state.dataLoopNodes->NodeID(unitVent.FanOutletNode),
                                                          state.dataLoopNodes->NodeID(unitVent.AirOutNode));
                 } break;
@@ -857,8 +839,8 @@ namespace UnitVentilator {
                     BranchNodeConnections::SetUpCompSets(state,
                                                          CurrentModuleObject,
                                                          unitVent.Name,
-                                                         cCoolingCoilType,
-                                                         unitVent.CCoilName,
+                                                         HVAC::coilTypeNames[(int)unitVent.coolCoilType],
+                                                         unitVent.CoolCoilName,
                                                          state.dataLoopNodes->NodeID(unitVent.FanOutletNode),
                                                          state.dataLoopNodes->NodeID(unitVent.AirOutNode));
                 } break;
@@ -881,7 +863,6 @@ namespace UnitVentilator {
         for (int UnitVentNum = 1; UnitVentNum <= state.dataUnitVentilators->NumOfUnitVents; ++UnitVentNum) {
 
             auto &unitVent = state.dataUnitVentilators->UnitVent(UnitVentNum);
-            auto &coilReportObj = state.dataRptCoilSelection->coilSelectionReportObj;
 
             SetupOutputVariable(state,
                                 "Zone Unit Ventilator Heating Rate",
@@ -957,13 +938,13 @@ namespace UnitVentilator {
                                     unitVent.Name);
             }
 
-            if (unitVent.HCoilPresent) {
-                coilReportObj->setCoilSupplyFanInfo(
-                    state, unitVent.HCoilName, unitVent.HCoilTypeCh, unitVent.FanName, unitVent.fanType, unitVent.Fan_Index);
+            if (unitVent.HeatCoilPresent) {
+                ReportCoilSelection::setCoilSupplyFanInfo(
+                    state, unitVent.HeatCoilName, unitVent.heatCoilType, unitVent.FanName, unitVent.fanType, unitVent.Fan_Index);
             }
-            if (unitVent.CCoilPresent) {
-                coilReportObj->setCoilSupplyFanInfo(
-                    state, unitVent.CCoilName, unitVent.CCoilTypeCh, unitVent.FanName, unitVent.fanType, unitVent.Fan_Index);
+            if (unitVent.CoolCoilPresent) {
+                ReportCoilSelection::setCoilSupplyFanInfo(
+                    state, unitVent.CoolCoilName, unitVent.coolCoilType, unitVent.FanName, unitVent.fanType, unitVent.Fan_Index);
             }
         }
     }
@@ -1018,31 +999,33 @@ namespace UnitVentilator {
         }
 
         if (state.dataUnitVentilators->MyPlantScanFlag(UnitVentNum) && allocated(state.dataPlnt->PlantLoop)) {
-            if ((unitVent.HeatingCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
-                (unitVent.HeatingCoilType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
+            if ((unitVent.HeatCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
+                (unitVent.HeatCoilPlantType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
                 bool errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(
-                    state, unitVent.HCoilName, unitVent.HeatingCoilType, unitVent.HWplantLoc, errFlag, _, _, _, _, _);
+                    state, unitVent.HeatCoilName, unitVent.HeatCoilPlantType, unitVent.HWplantLoc, errFlag, _, _, _, _, _);
                 if (errFlag) {
                     ShowContinueError(state, format("Reference Unit=\"{}\", type=ZoneHVAC:UnitVentilator", unitVent.Name));
                     ShowFatalError(state, "InitUnitVentilator: Program terminated due to previous condition(s).");
                 }
 
-                unitVent.HotCoilOutNodeNum = DataPlant::CompData::getPlantComponent(state, unitVent.HWplantLoc).NodeNumOut;
+                // Why do we sometimes get it from the coil object and sometimes from the plant component?  Are these the same?
+                unitVent.HeatCoilWaterOutNodeNum = DataPlant::CompData::getPlantComponent(state, unitVent.HWplantLoc).NodeNumOut;
             }
-            if ((unitVent.CoolingCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
-                (unitVent.CoolingCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) {
+            
+            if ((unitVent.CoolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
+                (unitVent.CoolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) {
                 bool errFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(
-                    state, unitVent.CCoilPlantName, unitVent.CoolingCoilType, unitVent.CWPlantLoc, errFlag, _, _, _, _, _);
+                    state, unitVent.CoolCoilName, unitVent.CoolCoilPlantType, unitVent.CWPlantLoc, errFlag, _, _, _, _, _);
                 if (errFlag) {
                     ShowContinueError(state, format("Reference Unit=\"{}\", type=ZoneHVAC:UnitVentilator", unitVent.Name));
                     ShowFatalError(state, "InitUnitVentilator: Program terminated due to previous condition(s).");
                 }
 
-                unitVent.ColdCoilOutNodeNum = DataPlant::CompData::getPlantComponent(state, unitVent.CWPlantLoc).NodeNumOut;
+                unitVent.CoolCoilWaterOutNodeNum = DataPlant::CompData::getPlantComponent(state, unitVent.CWPlantLoc).NodeNumOut;
             } else {
-                if (unitVent.CCoilPresent)
+                if (unitVent.CoolCoilPresent)
                     ShowFatalError(state, format("InitUnitVentilator: Unit={}, invalid cooling coil type. Program terminated.", unitVent.Name));
             }
             state.dataUnitVentilators->MyPlantScanFlag(UnitVentNum) = false;
@@ -1101,9 +1084,9 @@ namespace UnitVentilator {
             state.dataLoopNodes->Node(InNode).MassFlowRateMax = unitVent.MaxAirMassFlow;
             state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
 
-            if (unitVent.HCoilPresent) { // Only initialize these if a heating coil is actually present
+            if (unitVent.HeatCoilPresent) { // Only initialize these if a heating coil is actually present
 
-                if (unitVent.HCoilType == HeatCoilType::Water) {
+                if (unitVent.heatCoilType == HVAC::CoilType::HeatingWater) {
 
                     Real64 rho =
                         state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
@@ -1112,26 +1095,26 @@ namespace UnitVentilator {
                     unitVent.MinHotWaterFlow = rho * unitVent.MinVolHotWaterFlow;
 
                     PlantUtilities::InitComponentNodes(
-                        state, unitVent.MinHotWaterFlow, unitVent.MaxHotWaterFlow, unitVent.HotControlNode, unitVent.HotCoilOutNodeNum);
-                }
-                if (unitVent.HCoilType == HeatCoilType::Steam) {
+                        state, unitVent.MinHotWaterFlow, unitVent.MaxHotWaterFlow, unitVent.HeatCoilControlNodeNum, unitVent.HeatCoilWaterOutNodeNum);
+
+                } else if (unitVent.heatCoilType == HVAC::CoilType::HeatingSteam) {
                     Real64 TempSteamIn = 100.00;
-                    Real64 SteamDensity = unitVent.HCoil_fluid->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
+                    Real64 SteamDensity = unitVent.HeatCoilFluid->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
                     unitVent.MaxHotSteamFlow = SteamDensity * unitVent.MaxVolHotSteamFlow;
                     unitVent.MinHotSteamFlow = SteamDensity * unitVent.MinVolHotSteamFlow;
 
                     PlantUtilities::InitComponentNodes(
-                        state, unitVent.MinHotSteamFlow, unitVent.MaxHotSteamFlow, unitVent.HotControlNode, unitVent.HotCoilOutNodeNum);
+                        state, unitVent.MinHotSteamFlow, unitVent.MaxHotSteamFlow, unitVent.HeatCoilControlNodeNum, unitVent.HeatCoilWaterOutNodeNum);
                 }
             } //(UnitVent(UnitVentNum)%HCoilPresent)
 
-            if (unitVent.CCoilPresent) { // Only initialize these if a cooling coil is actually present
+            if (unitVent.CoolCoilPresent) { // Only initialize these if a cooling coil is actually present
                 Real64 rho = state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).glycol->getDensity(state, 5.0, RoutineName);
 
                 unitVent.MaxColdWaterFlow = rho * unitVent.MaxVolColdWaterFlow;
                 unitVent.MinColdWaterFlow = rho * unitVent.MinVolColdWaterFlow;
                 PlantUtilities::InitComponentNodes(
-                    state, unitVent.MinColdWaterFlow, unitVent.MaxColdWaterFlow, unitVent.ColdControlNode, unitVent.ColdCoilOutNodeNum);
+                    state, unitVent.MinColdWaterFlow, unitVent.MaxColdWaterFlow, unitVent.CoolCoilControlNodeNum, unitVent.CoolCoilWaterOutNodeNum);
             }
             state.dataUnitVentilators->MyEnvrnFlag(UnitVentNum) = false;
         } // ...end start of environment inits
@@ -1252,8 +1235,6 @@ namespace UnitVentilator {
         Real64 LatentHeatSteam = 0.0;
         Real64 SteamDensity = 0.0;
         int CoilWaterOutletNode = 0;
-        std::string CoolingCoilName;
-        std::string CoolingCoilType;
         Real64 rho = 0.0;
         Real64 Cp = 0.0;
 
@@ -1282,7 +1263,7 @@ namespace UnitVentilator {
         Real64 HeatingAirVolFlowScalable = 0.0;
         state.dataSize->DataScalableSizingON = false;
         state.dataSize->DataScalableCapSizingON = false;
-        std::string CompType = state.dataUnitVentilators->cMO_UnitVentilator;
+        std::string CompType = std::string{CMO_UnitVentilator};
         std::string CompName = unitVent.Name;
         state.dataSize->DataZoneNumber = unitVent.ZonePtr;
         bool DoWaterCoilSizing = false;
@@ -1631,13 +1612,13 @@ namespace UnitVentilator {
             if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // Simulation continue
                 if (unitVent.OutAirVolFlow > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataUnitVentilators->cMO_UnitVentilator,
+                                                 CMO_UnitVentilator,
                                                  unitVent.Name,
                                                  "User-Specified Maximum Outdoor Air Flow Rate [m3/s]",
                                                  unitVent.OutAirVolFlow);
                 }
             } else {
-                CheckZoneSizing(state, state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name);
+                CheckZoneSizing(state, CMO_UnitVentilator, unitVent.Name);
                 if (unitVent.OAControlType == OAControl::FixedAmount) {
                     OutAirVolFlowDes = min(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).MinOA, unitVent.MaxAirVolFlow);
                 } else {
@@ -1647,7 +1628,7 @@ namespace UnitVentilator {
                 if (IsAutoSize) {
                     unitVent.OutAirVolFlow = OutAirVolFlowDes;
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataUnitVentilators->cMO_UnitVentilator,
+                                                 CMO_UnitVentilator,
                                                  unitVent.Name,
                                                  "Design Size Maximum Outdoor Air Flow Rate [m3/s]",
                                                  OutAirVolFlowDes);
@@ -1655,7 +1636,7 @@ namespace UnitVentilator {
                     if (unitVent.OutAirVolFlow > 0.0 && OutAirVolFlowDes > 0.0) {
                         OutAirVolFlowUser = unitVent.OutAirVolFlow;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "Design Size Maximum Outdoor Air Flow Rate [m3/s]",
                                                      OutAirVolFlowDes,
@@ -1665,7 +1646,7 @@ namespace UnitVentilator {
                             if ((std::abs(OutAirVolFlowDes - OutAirVolFlowUser) / OutAirVolFlowUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state,
                                             format("SizeUnitVentilator: Potential issue with equipment sizing for {} {}",
-                                                   state.dataUnitVentilators->cMO_UnitVentilator,
+                                                   CMO_UnitVentilator,
                                                    unitVent.Name));
                                 ShowContinueError(state, format("User-Specified Maximum Outdoor Air Flow Rate of {:.5R} [m3/s]", OutAirVolFlowUser));
                                 ShowContinueError(
@@ -1693,13 +1674,13 @@ namespace UnitVentilator {
             if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // Simulation continue
                 if (unitVent.MinOutAirVolFlow > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataUnitVentilators->cMO_UnitVentilator,
+                                                 CMO_UnitVentilator,
                                                  unitVent.Name,
                                                  "User-Specified Minimum Outdoor Air Flow Rate [m3/s]",
                                                  unitVent.MinOutAirVolFlow);
                 }
             } else {
-                CheckZoneSizing(state, state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name);
+                CheckZoneSizing(state, CMO_UnitVentilator, unitVent.Name);
                 MinOutAirVolFlowDes = min(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).MinOA, unitVent.MaxAirVolFlow);
                 if (MinOutAirVolFlowDes < HVAC::SmallAirVolFlow) {
                     MinOutAirVolFlowDes = 0.0;
@@ -1707,7 +1688,7 @@ namespace UnitVentilator {
                 if (IsAutoSize) {
                     unitVent.MinOutAirVolFlow = MinOutAirVolFlowDes;
                     BaseSizer::reportSizerOutput(state,
-                                                 state.dataUnitVentilators->cMO_UnitVentilator,
+                                                 CMO_UnitVentilator,
                                                  unitVent.Name,
                                                  "Design Size Minimum Outdoor Air Flow Rate [m3/s]",
                                                  MinOutAirVolFlowDes);
@@ -1715,7 +1696,7 @@ namespace UnitVentilator {
                     if (unitVent.MinOutAirVolFlow > 0.0 && MinOutAirVolFlowDes > 0.0) {
                         MinOutAirVolFlowUser = unitVent.MinOutAirVolFlow;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "Design Size Minimum Outdoor Air Flow Rate [m3/s]",
                                                      MinOutAirVolFlowDes,
@@ -1726,7 +1707,7 @@ namespace UnitVentilator {
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state,
                                             format("SizeUnitVentilator: Potential issue with equipment sizing for {} = \"{}\".",
-                                                   state.dataUnitVentilators->cMO_UnitVentilator,
+                                                   CMO_UnitVentilator,
                                                    unitVent.Name));
                                 ShowContinueError(state,
                                                   format("User-Specified Minimum Outdoor Air Flow Rate of {:.5R} [m3/s]", MinOutAirVolFlowUser));
@@ -1745,26 +1726,24 @@ namespace UnitVentilator {
         if (unitVent.MaxVolHotWaterFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
-        if (unitVent.HCoilType == HeatCoilType::Water) {
+        if (unitVent.heatCoilType == HVAC::CoilType::HeatingWater) {
             if (state.dataSize->CurZoneEqNum > 0) {
                 if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // Simulation continue
                     if (unitVent.MaxVolHotWaterFlow > 0.0) {
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "User-Specified Maximum Hot Water Flow [m3/s]",
                                                      unitVent.MaxVolHotWaterFlow);
                     }
                 } else {
-                    CheckZoneSizing(state, state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name);
-
-                    CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, "Coil:Heating:Water", unitVent.HCoilName, ErrorsFound);
+                    CheckZoneSizing(state, CMO_UnitVentilator, unitVent.Name);
                     if (IsAutoSize) {
                         PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(
-                            state, "COIL:HEATING:WATER", unitVent.HCoilName, unitVent.HotControlNode, CoilWaterOutletNode, ErrorsFound);
+                            state, "COIL:HEATING:WATER", unitVent.HeatCoilName, unitVent.HeatCoilControlNodeNum, unitVent.HeatCoilWaterOutNodeNum, ErrorsFound);
 
-                        if (state.dataWaterCoils->WaterCoil(unitVent.HCoil_Index).UseDesignWaterDeltaTemp) {
-                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(unitVent.HCoil_Index).DesignWaterDeltaTemp;
+                        if (state.dataWaterCoils->WaterCoil(unitVent.HeatCoilNum).UseDesignWaterDeltaTemp) {
+                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(unitVent.HeatCoilNum).DesignWaterDeltaTemp;
                             DoWaterCoilSizing = true;
                         } else {
                             if (PltSizHeatNum > 0) {
@@ -1774,8 +1753,7 @@ namespace UnitVentilator {
                                 DoWaterCoilSizing = false;
                                 // If there is no heating Plant Sizing object and autosizing was requested, issue fatal error message
                                 ShowSevereError(state, "Autosizing of water flow requires a heating loop Sizing:Plant object");
-                                ShowContinueError(state,
-                                                  format("Occurs in {} = \"{}\"", state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name));
+                                ShowContinueError(state, format("Occurs in {} = \"{}\"", CMO_UnitVentilator, unitVent.Name));
                                 ErrorsFound = true;
                             }
                         }
@@ -1850,7 +1828,7 @@ namespace UnitVentilator {
                         }
                         unitVent.MaxVolHotWaterFlow = MaxVolHotWaterFlowDes;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "Design Size Maximum Hot Water Flow [m3/s]",
                                                      MaxVolHotWaterFlowDes);
@@ -1858,7 +1836,7 @@ namespace UnitVentilator {
                         if (unitVent.MaxVolHotWaterFlow > 0.0 && MaxVolHotWaterFlowDes > 0.0) {
                             MaxVolHotWaterFlowUser = unitVent.MaxVolHotWaterFlow;
                             BaseSizer::reportSizerOutput(state,
-                                                         state.dataUnitVentilators->cMO_UnitVentilator,
+                                                         CMO_UnitVentilator,
                                                          unitVent.Name,
                                                          "Design Size Maximum Hot Water Flow [m3/s]",
                                                          MaxVolHotWaterFlowDes,
@@ -1869,7 +1847,7 @@ namespace UnitVentilator {
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
                                                 format("SizeUnitVentilator: Potential issue with equipment sizing for {} {}",
-                                                       state.dataUnitVentilators->cMO_UnitVentilator,
+                                                       CMO_UnitVentilator,
                                                        unitVent.Name));
                                     ShowContinueError(state,
                                                       format("User-Specified Maximum Hot Water Flow of {:.5R} [m3/s]", MaxVolHotWaterFlowUser));
@@ -1891,23 +1869,23 @@ namespace UnitVentilator {
         if (unitVent.MaxVolHotSteamFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
-        if (unitVent.HCoilType == HeatCoilType::Steam) {
+        if (unitVent.heatCoilType == HVAC::CoilType::HeatingSteam) {
             if (state.dataSize->CurZoneEqNum > 0) {
                 if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // Simulation continue
                     if (unitVent.MaxVolHotSteamFlow > 0.0) {
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "User-Specified Maximum Steam Flow [m3/s]",
                                                      unitVent.MaxVolHotSteamFlow);
                     }
                 } else {
-                    CheckZoneSizing(state, state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name);
+                    CheckZoneSizing(state, CMO_UnitVentilator, unitVent.Name);
 
-                    int CoilSteamOutletNode = SteamCoils::GetCoilSteamOutletNode(state, "Coil:Heating:Steam", unitVent.HCoilName, ErrorsFound);
+                    int CoilSteamOutletNode = SteamCoils::GetCoilSteamOutletNode(state, unitVent.HeatCoilNum);
                     if (IsAutoSize) {
                         PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(
-                            state, "Coil:Heating:Steam", unitVent.HCoilName, unitVent.HotControlNode, CoilSteamOutletNode, ErrorsFound);
+                            state, "Coil:Heating:Steam", unitVent.HeatCoilName, unitVent.HeatCoilControlNodeNum, CoilSteamOutletNode, ErrorsFound);
                         if (PltSizHeatNum > 0) {
                             if (state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatMassFlow >= HVAC::SmallAirVolFlow) {
                                 SizingMethod = HVAC::HeatingCapacitySizing;
@@ -1976,12 +1954,12 @@ namespace UnitVentilator {
                             }
                         } else {
                             ShowSevereError(state, "Autosizing of Steam flow requires a heating loop Sizing:Plant object");
-                            ShowContinueError(state, format("Occurs in {} = \"{}\"", state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name));
+                            ShowContinueError(state, format("Occurs in {} = \"{}\"", CMO_UnitVentilator, unitVent.Name));
                             ErrorsFound = true;
                         }
                         unitVent.MaxVolHotSteamFlow = MaxVolHotSteamFlowDes;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "Design Size Maximum Steam Flow [m3/s]",
                                                      MaxVolHotSteamFlowDes);
@@ -1989,7 +1967,7 @@ namespace UnitVentilator {
                         if (unitVent.MaxVolHotSteamFlow > 0.0 && MaxVolHotSteamFlowDes > 0.0) {
                             MaxVolHotSteamFlowUser = unitVent.MaxVolHotSteamFlow;
                             BaseSizer::reportSizerOutput(state,
-                                                         state.dataUnitVentilators->cMO_UnitVentilator,
+                                                         CMO_UnitVentilator,
                                                          unitVent.Name,
                                                          "Design Size Maximum Steam Flow [m3/s]",
                                                          MaxVolHotSteamFlowDes,
@@ -2000,7 +1978,7 @@ namespace UnitVentilator {
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
                                                 format("SizeUnitVentilator: Potential issue with equipment sizing for {} = \"{}\"",
-                                                       state.dataUnitVentilators->cMO_UnitVentilator,
+                                                       CMO_UnitVentilator,
                                                        unitVent.Name));
                                     ShowContinueError(state, format("User-Specified Maximum Steam Flow of {:.5R} [m3/s]", MaxVolHotSteamFlowUser));
                                     ShowContinueError(state,
@@ -2021,34 +1999,41 @@ namespace UnitVentilator {
         if (unitVent.MaxVolColdWaterFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
-        if (unitVent.CCoilType == CoolCoilType::Water || unitVent.CCoilType == CoolCoilType::Detailed ||
-            unitVent.CCoilType == CoolCoilType::HXAssisted) {
+        
+        if (unitVent.coolCoilType == HVAC::CoilType::CoolingWater ||
+            unitVent.coolCoilType == HVAC::CoilType::CoolingWaterDetailed ||
+            unitVent.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
 
             if (state.dataSize->CurZoneEqNum > 0) {
                 if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) { // Simulation continue
                     if (unitVent.MaxVolColdWaterFlow > 0.0) {
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "User-Specified Maximum Cold Water Flow [m3/s]",
                                                      unitVent.MaxVolColdWaterFlow);
                     }
                 } else {
-                    CheckZoneSizing(state, state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name);
-
-                    if (unitVent.CCoilType == CoolCoilType::HXAssisted) {
-                        CoolingCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, unitVent.CCoilTypeCh, unitVent.CCoilName, ErrorsFound);
-                        CoolingCoilType = HVACHXAssistedCoolingCoil::GetHXCoilType(state, unitVent.CCoilTypeCh, unitVent.CCoilName, ErrorsFound);
+                    CheckZoneSizing(state, CMO_UnitVentilator, unitVent.Name);
+
+                    std::string CoolCoilName;
+                    HVAC::CoilType CoolCoilType;
+                    int CoolCoilNum;
+                    
+                    if (unitVent.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                        CoolCoilName = unitVent.ChildCoolCoilName;
+                        CoolCoilType = unitVent.ChildCoolCoilType;
+                        CoolCoilNum = unitVent.ChildCoolCoilNum;
                     } else {
-                        CoolingCoilName = unitVent.CCoilName;
-                        CoolingCoilType = unitVent.CCoilTypeCh;
+                        CoolCoilName = unitVent.CoolCoilName;
+                        CoolCoilType = unitVent.coolCoilType;
+                        CoolCoilNum = unitVent.CoolCoilNum;
                     }
-                    CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
                     if (IsAutoSize) {
                         int PltSizCoolNum = PlantUtilities::MyPlantSizingIndex(
-                            state, CoolingCoilType, CoolingCoilName, unitVent.ColdControlNode, CoilWaterOutletNode, ErrorsFound);
-                        if (state.dataWaterCoils->WaterCoil(unitVent.CCoil_Index).UseDesignWaterDeltaTemp) {
-                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(unitVent.CCoil_Index).DesignWaterDeltaTemp;
+                            state, HVAC::coilTypeNames[(int)CoolCoilType], CoolCoilName, unitVent.CoolCoilControlNodeNum, unitVent.CoolCoilWaterOutNodeNum, ErrorsFound);
+                        if (state.dataWaterCoils->WaterCoil(CoolCoilNum).UseDesignWaterDeltaTemp) {
+                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoolCoilNum).DesignWaterDeltaTemp;
                             DoWaterCoilSizing = true;
                         } else {
                             if (PltSizCoolNum > 0) {
@@ -2059,7 +2044,7 @@ namespace UnitVentilator {
                                 // If there is no cooling Plant Sizing object and autosizing was requested, issue fatal error message
                                 ShowSevereError(state, "Autosizing of water coil requires a cooling loop Sizing:Plant object");
                                 ShowContinueError(state,
-                                                  format("Occurs in {} = \"{}\"", state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name));
+                                                  format("Occurs in {} = \"{}\"", CMO_UnitVentilator, unitVent.Name));
                                 ErrorsFound = true;
                             }
                         }
@@ -2120,7 +2105,7 @@ namespace UnitVentilator {
                                 if (MaxVolColdWaterFlowDes < 0.0) {
                                     ShowWarningError(state, "Autosizing of water flow resulted in negative value.");
                                     ShowContinueError(state,
-                                                      format("Occurs in {} = \"{}\"", state.dataUnitVentilators->cMO_UnitVentilator, unitVent.Name));
+                                                      format("Occurs in {} = \"{}\"", CMO_UnitVentilator, unitVent.Name));
                                     ShowContinueError(state, "...Sizing information found during sizing simulation:");
                                     ShowContinueError(state, format("...Calculated coil design load = {:.3T} W", DesCoolingLoad));
                                     ShowContinueError(state, format("...Calculated water flow rate  = {:.3T} m3/s", MaxVolColdWaterFlowDes));
@@ -2136,7 +2121,7 @@ namespace UnitVentilator {
                         }
                         unitVent.MaxVolColdWaterFlow = MaxVolColdWaterFlowDes;
                         BaseSizer::reportSizerOutput(state,
-                                                     state.dataUnitVentilators->cMO_UnitVentilator,
+                                                     CMO_UnitVentilator,
                                                      unitVent.Name,
                                                      "Design Size Maximum Cold Water Flow [m3/s]",
                                                      MaxVolColdWaterFlowDes);
@@ -2144,7 +2129,7 @@ namespace UnitVentilator {
                         if (unitVent.MaxVolColdWaterFlow > 0.0 && MaxVolColdWaterFlowDes > 0.0) {
                             MaxVolColdWaterFlowUser = unitVent.MaxVolColdWaterFlow;
                             BaseSizer::reportSizerOutput(state,
-                                                         state.dataUnitVentilators->cMO_UnitVentilator,
+                                                         CMO_UnitVentilator,
                                                          unitVent.Name,
                                                          "Design Size Maximum Cold Water Flow [m3/s]",
                                                          MaxVolColdWaterFlowDes,
@@ -2155,7 +2140,7 @@ namespace UnitVentilator {
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state,
                                                 format("SizeUnitVentilator: Potential issue with equipment sizing for {} = \"{}\"",
-                                                       state.dataUnitVentilators->cMO_UnitVentilator,
+                                                       CMO_UnitVentilator,
                                                        unitVent.Name));
                                     ShowContinueError(state,
                                                       format("User-Specified Maximum Cold Water Flow of {:.5R} [m3/s]", MaxVolColdWaterFlowUser));
@@ -2172,15 +2157,22 @@ namespace UnitVentilator {
         }
 
         // set the design air flow rates for the heating and cooling coils
-        if (unitVent.CCoilType == CoolCoilType::HXAssisted) {
-            CoolingCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, unitVent.CCoilTypeCh, unitVent.CCoilName, ErrorsFound);
-            CoolingCoilType = HVACHXAssistedCoolingCoil::GetHXCoilType(state, unitVent.CCoilTypeCh, unitVent.CCoilName, ErrorsFound);
-        } else {
-            CoolingCoilName = unitVent.CCoilName;
-            CoolingCoilType = unitVent.CCoilTypeCh;
+        if (unitVent.CoilOption == CoilsUsed::Both || unitVent.CoilOption == CoilsUsed::Cooling) {
+            if (unitVent.coolCoilType == HVAC::CoilType::CoolingWater ||
+                unitVent.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) { 
+                WaterCoils::SetCoilDesFlow(state, unitVent.CoolCoilNum, unitVent.MaxAirVolFlow);
+            } else if (unitVent.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                WaterCoils::SetCoilDesFlow(state, unitVent.ChildCoolCoilNum, unitVent.MaxAirVolFlow);
+            }
+            // No DX coils? 
+        }
+
+        if (unitVent.CoilOption == CoilsUsed::Both || unitVent.CoilOption == CoilsUsed::Heating) {
+            if (unitVent.heatCoilType == HVAC::CoilType::HeatingWater) {
+                WaterCoils::SetCoilDesFlow(state, unitVent.HeatCoilNum, unitVent.MaxAirVolFlow);
+            }
+            // No steam or electric/gas coils?
         }
-        WaterCoils::SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, unitVent.MaxAirVolFlow, ErrorsFound);
-        WaterCoils::SetCoilDesFlow(state, unitVent.HCoilTypeCh, unitVent.HCoilName, unitVent.MaxAirVolFlow, ErrorsFound);
 
         if (state.dataSize->CurZoneEqNum > 0) {
             ZoneEqSizing.MaxHWVolFlow = unitVent.MaxVolHotWaterFlow;
@@ -2262,53 +2254,36 @@ namespace UnitVentilator {
         Real64 Toutdoor;    // temperature of outdoor air being introduced into the unit ventilator [degrees C]
         Real64 mdot;
 
-        switch (unitVent.CoilOption) {
-        case CoilsUsed::Both:
-        case CoilsUsed::Heating: {
-            switch (unitVent.HCoilType) {
-            case HeatCoilType::Water: {
-                WaterCoils::CheckWaterCoilSchedule(state, unitVent.HCoilName, unitVent.HCoilSchedValue, unitVent.HCoil_Index);
-            } break;
-            case HeatCoilType::Steam: {
-                SteamCoils::CheckSteamCoilSchedule(state, "Coil:Heating:Steam", unitVent.HCoilName, unitVent.HCoilSchedValue, unitVent.HCoil_Index);
+        if (unitVent.CoilOption == CoilsUsed::Both || unitVent.CoilOption == CoilsUsed::Heating) {
+            switch (unitVent.heatCoilType) {
+            case HVAC::CoilType::HeatingWater: {
+                unitVent.HeatCoilSchedVal = WaterCoils::GetCoilScheduleValue(state, unitVent.HeatCoilNum);
             } break;
-            case HeatCoilType::Electric: {
-                HeatingCoils::CheckHeatingCoilSchedule(
-                    state, "Coil:Heating:Electric", unitVent.HCoilName, unitVent.HCoilSchedValue, unitVent.HCoil_Index);
+            case HVAC::CoilType::HeatingSteam: {
+                unitVent.HeatCoilSchedVal = SteamCoils::GetCoilScheduleValue(state, unitVent.HeatCoilNum);
             } break;
-            case HeatCoilType::Gas: {
-                HeatingCoils::CheckHeatingCoilSchedule(
-                    state, "Coil:Heating:Fuel", unitVent.HCoilName, unitVent.HCoilSchedValue, unitVent.HCoil_Index);
+            case HVAC::CoilType::HeatingElectric: 
+            case HVAC::CoilType::HeatingGasOrOtherFuel: {
+                unitVent.HeatCoilSchedVal = HeatingCoils::GetCoilScheduleValue(state, unitVent.HeatCoilNum);
             } break;
             default: {
             } break;
-            }
-        } break;
-        default: {
-        } break;
+            } // switch
         }
 
-        switch (unitVent.CoilOption) {
-        case CoilsUsed::Both:
-        case CoilsUsed::Cooling: {
-            switch (unitVent.CCoilType) {
-            case CoolCoilType::Water: {
-                WaterCoils::CheckWaterCoilSchedule(state, unitVent.CCoilName, unitVent.CCoilSchedValue, unitVent.CCoil_Index);
+        if (unitVent.CoilOption == CoilsUsed::Both || unitVent.CoilOption == CoilsUsed::Cooling) {
+            switch (unitVent.coolCoilType) {
+            case HVAC::CoilType::CoolingWater: 
+            case HVAC::CoilType::CoolingWaterDetailed: {
+                unitVent.CoolCoilSchedVal = WaterCoils::GetCoilScheduleValue(state, unitVent.CoolCoilNum);
             } break;
-            case CoolCoilType::Detailed: {
-                WaterCoils::CheckWaterCoilSchedule(state, unitVent.CCoilName, unitVent.CCoilSchedValue, unitVent.CCoil_Index);
-            } break;
-            case CoolCoilType::HXAssisted: {
-                HVACHXAssistedCoolingCoil::CheckHXAssistedCoolingCoilSchedule(
-                    state, "CoilSystem:Cooling:Water:HeatExchangerAssisted", unitVent.CCoilName, unitVent.CCoilSchedValue, unitVent.CCoil_Index);
+            case HVAC::CoilType::CoolingWaterHXAssisted: {
+                unitVent.CoolCoilSchedVal = HXAssistCoil::GetCoilScheduleValue(state, unitVent.CoolCoilNum);
             } break;
             default: {
                 assert(false);
             } break;
             }
-        } break;
-        default: {
-        } break;
         }
 
         // initialize local variables
@@ -2333,13 +2308,13 @@ namespace UnitVentilator {
             // simulate the components with the no flow conditions
             AirMassFlow = outletNode.MassFlowRate;
             state.dataUnitVentilators->HCoilOn = false;
-            if (unitVent.HotControlNode > 0) {
+            if (unitVent.HeatCoilControlNodeNum > 0) {
                 mdot = 0.0;
-                PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.HotControlNode, unitVent.HotCoilOutNodeNum, unitVent.HWplantLoc);
+                PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.HeatCoilControlNodeNum, unitVent.HeatCoilWaterOutNodeNum, unitVent.HWplantLoc);
             }
-            if (unitVent.ColdControlNode > 0) {
+            if (unitVent.CoolCoilControlNodeNum > 0) {
                 mdot = 0.0;
-                PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.ColdControlNode, unitVent.ColdCoilOutNodeNum, unitVent.CWPlantLoc);
+                PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.CoolCoilControlNodeNum, unitVent.CoolCoilWaterOutNodeNum, unitVent.CWPlantLoc);
             }
 
             if (fanOp == HVAC::FanOp::Cycling) {
@@ -2356,13 +2331,13 @@ namespace UnitVentilator {
             unitVent.FanPartLoadRatio = 1.0;
             if (state.dataUnitVentilators->QZnReq > HVAC::SmallLoad) { // HEATING MODE
 
-                int ControlNode = unitVent.HotControlNode;
-                ControlOffset = unitVent.HotControlOffset;
+                int ControlNode = unitVent.HeatCoilControlNodeNum;
+                ControlOffset = unitVent.HeatCoilControlOffset;
                 MaxWaterFlow = unitVent.MaxHotWaterFlow;
                 MinWaterFlow = unitVent.MinHotWaterFlow;
                 // On the first HVAC iteration the system values are given to the controller, but after that
                 // the demand limits are in place and there needs to be feedback to the Zone Equipment
-                if (!FirstHVACIteration && unitVent.HCoilType == HeatCoilType::Water) {
+                if (!FirstHVACIteration && unitVent.heatCoilType == HVAC::CoilType::HeatingWater) {
                     MaxWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMaxAvail;
                     MinWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMinAvail;
                 }
@@ -2376,7 +2351,7 @@ namespace UnitVentilator {
                 }
                 MinOAFrac = min(1.0, max(0.0, MinOAFrac));
 
-                if ((!unitVent.HCoilPresent) || (unitVent.HCoilSchedValue <= 0.0)) {
+                if ((!unitVent.HeatCoilPresent) || (unitVent.HeatCoilSchedVal <= 0.0)) {
                     // In heating mode, but there is no coil to provide heating.  This is handled
                     // differently than if there was a heating coil present.  Fixed temperature
                     // will still try to vary the amount of outside air to meet the desired
@@ -2578,51 +2553,50 @@ namespace UnitVentilator {
 
                     } else { // Not a cycling operating mode
 
-                        {
-                            switch (unitVent.HCoilType) {
-                            case HeatCoilType::Water: {
-                                // control water flow to obtain output matching QZnReq
-                                ControlCompOutput(state,
-                                                  unitVent.Name,
-                                                  state.dataUnitVentilators->cMO_UnitVentilator,
-                                                  UnitVentNum,
-                                                  FirstHVACIteration,
-                                                  state.dataUnitVentilators->QZnReq,
-                                                  ControlNode,
-                                                  MaxWaterFlow,
-                                                  MinWaterFlow,
-                                                  ControlOffset,
-                                                  unitVent.ControlCompTypeNum,
-                                                  unitVent.CompErrIndex,
-                                                  _,
-                                                  _,
-                                                  _,
-                                                  _,
-                                                  _,
-                                                  unitVent.HWplantLoc);
-                            } break;
-                            case HeatCoilType::Gas:
-                            case HeatCoilType::Electric:
-                            case HeatCoilType::Steam: {
-                                CalcUnitVentilatorComponents(state, UnitVentNum, FirstHVACIteration, QUnitOut);
-                            } break;
-                            default: {
-                                assert(false);
-                            } break;
-                            }
-                        }
+                        switch (unitVent.heatCoilType) {
+                        case HVAC::CoilType::HeatingWater: {
+                            // control water flow to obtain output matching QZnReq
+                            ControlCompOutput(state,
+                                              unitVent.Name,
+                                              CMO_UnitVentilator,
+                                              UnitVentNum,
+                                              FirstHVACIteration,
+                                              state.dataUnitVentilators->QZnReq,
+                                              ControlNode,
+                                              MaxWaterFlow,
+                                              MinWaterFlow,
+                                              ControlOffset,
+                                              unitVent.ControlCompTypeNum,
+                                              unitVent.CompErrIndex,
+                                              _,
+                                              _,
+                                              _,
+                                              _,
+                                              _,
+                                              unitVent.HWplantLoc);
+                        } break;
+                          
+                        case HVAC::CoilType::HeatingGasOrOtherFuel:
+                        case HVAC::CoilType::HeatingElectric:
+                        case HVAC::CoilType::HeatingSteam: {
+                          CalcUnitVentilatorComponents(state, UnitVentNum, FirstHVACIteration, QUnitOut);
+                        } break;
+                        default: {
+                          assert(false);
+                        } break;
+                        } // switch ()
                     }
                 } //  Coil/no coil block
 
             } else { // COOLING MODE
 
-                int ControlNode = unitVent.ColdControlNode;
-                ControlOffset = unitVent.ColdControlOffset;
+                int ControlNode = unitVent.CoolCoilControlNodeNum;
+                ControlOffset = unitVent.CoolCoilControlOffset;
                 MaxWaterFlow = unitVent.MaxColdWaterFlow;
                 MinWaterFlow = unitVent.MinColdWaterFlow;
                 // On the first HVAC iteration the system values are given to the controller, but after that
                 // the demand limits are in place and there needs to be feedback to the Zone Equipment
-                if ((!FirstHVACIteration) && (ControlNode > 0) && (unitVent.CCoilPresent)) {
+                if ((!FirstHVACIteration) && (ControlNode > 0) && (unitVent.CoolCoilPresent)) {
                     MaxWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMaxAvail;
                     MinWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMinAvail;
                 }
@@ -2638,7 +2612,7 @@ namespace UnitVentilator {
                 }
                 MinOAFrac = min(1.0, max(0.0, MinOAFrac));
 
-                if ((!unitVent.CCoilPresent) || (unitVent.CCoilSchedValue <= 0.0)) {
+                if ((!unitVent.CoolCoilPresent) || (unitVent.CoolCoilSchedVal <= 0.0)) {
                     // In cooling mode, but there is no coil to provide cooling.  This is handled
                     // differently than if there was a cooling coil present.  Fixed temperature
                     // will still try to vary the amount of outside air to meet the desired
@@ -2814,7 +2788,7 @@ namespace UnitVentilator {
                         state.dataUnitVentilators->HCoilOn = false;
                         ControlCompOutput(state,
                                           unitVent.Name,
-                                          state.dataUnitVentilators->cMO_UnitVentilator,
+                                          CMO_UnitVentilator,
                                           UnitVentNum,
                                           FirstHVACIteration,
                                           state.dataUnitVentilators->QZnReq,
@@ -2913,58 +2887,58 @@ namespace UnitVentilator {
                 state.dataFans->fans(unitVent.Fan_Index)->simulate(state, FirstHVACIteration);
             }
 
-            if (unitVent.CCoilPresent) {
-                if (unitVent.CCoilType == CoolCoilType::HXAssisted) {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
-                        state, unitVent.CCoilName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, unitVent.CCoil_Index, HVAC::FanOp::Continuous);
+            if (unitVent.CoolCoilPresent) {
+                if (unitVent.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(
+                        state, unitVent.CoolCoilName, FirstHVACIteration, HVAC::CompressorOp::On, 0.0, unitVent.CoolCoilNum, HVAC::FanOp::Continuous);
                 } else {
-                    WaterCoils::SimulateWaterCoilComponents(state, unitVent.CCoilName, FirstHVACIteration, unitVent.CCoil_Index);
+                    WaterCoils::SimulateWaterCoilComponents(state, unitVent.CoolCoilName, FirstHVACIteration, unitVent.CoolCoilNum);
                 }
             }
 
-            if (unitVent.HCoilPresent) {
-
-                {
-                    switch (unitVent.HCoilType) {
-                    case HeatCoilType::Water: {
-                        WaterCoils::SimulateWaterCoilComponents(state, unitVent.HCoilName, FirstHVACIteration, unitVent.HCoil_Index);
-                    } break;
-                    case HeatCoilType::Steam: {
-                        if (!state.dataUnitVentilators->HCoilOn) {
-                            QCoilReq = 0.0;
-                        } else {
-                            int HCoilInAirNode = unitVent.FanOutletNode;
-                            Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
-                            QCoilReq = state.dataUnitVentilators->QZnReq -
-                                       state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                           (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
-                        }
-
-                        if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
+            if (unitVent.HeatCoilPresent) {
 
-                        SteamCoils::SimulateSteamCoilComponents(state, unitVent.HCoilName, FirstHVACIteration, unitVent.HCoil_Index, QCoilReq);
-                    } break;
-                    case HeatCoilType::Electric:
-                    case HeatCoilType::Gas: {
-                        if (!state.dataUnitVentilators->HCoilOn) {
-                            QCoilReq = 0.0;
-                        } else {
-                            int HCoilInAirNode = unitVent.FanOutletNode;
-                            Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
-                            QCoilReq = state.dataUnitVentilators->QZnReq -
-                                       state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                           (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
-                        }
-
-                        if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
+                switch (unitVent.heatCoilType) {
+                case HVAC::CoilType::HeatingWater: {
+                    WaterCoils::SimulateWaterCoilComponents(state, unitVent.HeatCoilName, FirstHVACIteration, unitVent.HeatCoilNum);
+                } break;
+                  
+                case HVAC::CoilType::HeatingSteam: {
+                    if (!state.dataUnitVentilators->HCoilOn) {
+                        QCoilReq = 0.0;
+                    } else {
+                        int HCoilInAirNode = unitVent.FanOutletNode;
+                        Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
+                        QCoilReq = state.dataUnitVentilators->QZnReq -
+                            state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
+                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
+                    }
 
-                        HeatingCoils::SimulateHeatingCoilComponents(state, unitVent.HCoilName, FirstHVACIteration, QCoilReq, unitVent.HCoil_Index);
-                    } break;
-                    default: {
-                        assert(false);
-                    } break;
+                    if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
+                    
+                    SteamCoils::SimulateSteamCoilComponents(state, unitVent.HeatCoilName, FirstHVACIteration, unitVent.HeatCoilNum, QCoilReq);
+                } break;
+                  
+                case HVAC::CoilType::HeatingElectric:
+                case HVAC::CoilType::HeatingGasOrOtherFuel: {
+                    if (!state.dataUnitVentilators->HCoilOn) {
+                        QCoilReq = 0.0;
+                    } else {
+                        int HCoilInAirNode = unitVent.FanOutletNode;
+                        Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
+                        QCoilReq = state.dataUnitVentilators->QZnReq -
+                            state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
+                          (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
                     }
-                }
+
+                    if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
+                    
+                    HeatingCoils::SimulateHeatingCoilComponents(state, unitVent.HeatCoilName, FirstHVACIteration, QCoilReq, unitVent.HeatCoilNum);
+                } break;
+                default: {
+                  assert(false);
+                } break;
+                } // switch ()
 
             } // (UnitVent(UnitVentNum)%HCoilPresent)
 
@@ -2992,81 +2966,82 @@ namespace UnitVentilator {
 
             state.dataFans->fans(unitVent.Fan_Index)->simulate(state, FirstHVACIteration, _, _);
 
-            if (unitVent.CCoilPresent) {
+            if (unitVent.CoolCoilPresent) {
 
                 // where is mdot set ?
                 CalcMdotCCoilCycFan(state, mdot, QCoilReq, state.dataUnitVentilators->QZnReq, UnitVentNum, PartLoadFrac);
-                PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.ColdControlNode, unitVent.ColdCoilOutNodeNum, unitVent.CWPlantLoc);
+                PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.CoolCoilControlNodeNum, unitVent.CoolCoilWaterOutNodeNum, unitVent.CWPlantLoc);
 
-                if (unitVent.CCoilType == CoolCoilType::HXAssisted) {
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
-                        state, unitVent.CCoilName, FirstHVACIteration, HVAC::CompressorOp::On, PartLoadFrac, unitVent.CCoil_Index, fanOp);
+                if (unitVent.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(
+                        state, unitVent.CoolCoilName, FirstHVACIteration, HVAC::CompressorOp::On, PartLoadFrac, unitVent.CoolCoilNum, fanOp);
                 } else {
                     WaterCoils::SimulateWaterCoilComponents(
-                        state, unitVent.CCoilName, FirstHVACIteration, unitVent.CCoil_Index, QCoilReq, fanOp, PartLoadFrac);
+                        state, unitVent.CoolCoilName, FirstHVACIteration, unitVent.CoolCoilNum, QCoilReq, fanOp, PartLoadFrac);
                 }
             }
 
-            if (unitVent.HCoilPresent) {
+            if (unitVent.HeatCoilPresent) {
 
-                {
-                    switch (unitVent.HCoilType) {
-                    case HeatCoilType::Water: {
-                        if (!state.dataUnitVentilators->HCoilOn) {
-                            QCoilReq = 0.0;
-                            mdot = 0.0;
-                        } else {
-                            int HCoilInAirNode = unitVent.FanOutletNode;
-                            Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
-                            QCoilReq = state.dataUnitVentilators->QZnReq -
-                                       state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                           (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
-                            mdot = unitVent.MaxHotWaterFlow * PartLoadFrac;
-                        }
+                switch (unitVent.heatCoilType) {
+                case HVAC::CoilType::HeatingWater: {
+                    if (!state.dataUnitVentilators->HCoilOn) {
+                        QCoilReq = 0.0;
+                        mdot = 0.0;
+                    } else {
+                        int HCoilInAirNode = unitVent.FanOutletNode;
+                        Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
+                        QCoilReq = state.dataUnitVentilators->QZnReq -
+                            state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
+                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
+                        mdot = unitVent.MaxHotWaterFlow * PartLoadFrac;
+                    }
 
-                        if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
-                        PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.HotControlNode, unitVent.HotCoilOutNodeNum, unitVent.HWplantLoc);
-                        WaterCoils::SimulateWaterCoilComponents(
-                            state, unitVent.HCoilName, FirstHVACIteration, unitVent.HCoil_Index, QCoilReq, fanOp, PartLoadFrac);
-                    } break;
-                    case HeatCoilType::Steam: {
-                        if (!state.dataUnitVentilators->HCoilOn) {
-                            QCoilReq = 0.0;
-                            mdot = 0.0;
-                        } else {
-                            int HCoilInAirNode = unitVent.FanOutletNode;
-                            Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
-                            QCoilReq = state.dataUnitVentilators->QZnReq -
-                                       state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                           (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
-                            mdot = unitVent.MaxHotSteamFlow * PartLoadFrac;
-                        }
+                    if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
+                    PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.HeatCoilControlNodeNum, unitVent.HeatCoilWaterOutNodeNum, unitVent.HWplantLoc);
+                    WaterCoils::SimulateWaterCoilComponents(
+                        state, unitVent.HeatCoilName, FirstHVACIteration, unitVent.HeatCoilNum, QCoilReq, fanOp, PartLoadFrac);
+                } break;
 
-                        if (QCoilReq < 0.0) QCoilReq = 0.0;
-                        PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.HotControlNode, unitVent.HotCoilOutNodeNum, unitVent.HWplantLoc);
-                        SteamCoils::SimulateSteamCoilComponents(
-                            state, unitVent.HCoilName, FirstHVACIteration, unitVent.HCoil_Index, QCoilReq, _, fanOp, PartLoadFrac);
-                    } break;
-                    case HeatCoilType::Electric:
-                    case HeatCoilType::Gas: {
-                        if (!state.dataUnitVentilators->HCoilOn) {
-                            QCoilReq = 0.0;
-                        } else {
-                            int HCoilInAirNode = unitVent.FanOutletNode;
-                            Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
-                            QCoilReq = state.dataUnitVentilators->QZnReq -
-                                       state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
-                                           (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
-                        }
-                        if (QCoilReq < 0.0) QCoilReq = 0.0;
-                        HeatingCoils::SimulateHeatingCoilComponents(
-                            state, unitVent.HCoilName, FirstHVACIteration, QCoilReq, unitVent.HCoil_Index, _, _, fanOp, PartLoadFrac);
-                    } break;
-                    default: {
-                        assert(false);
-                    } break;
+                case HVAC::CoilType::HeatingSteam: {
+                    if (!state.dataUnitVentilators->HCoilOn) {
+                        QCoilReq = 0.0;
+                        mdot = 0.0;
+                    } else {
+                        int HCoilInAirNode = unitVent.FanOutletNode;
+                        Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
+                        QCoilReq = state.dataUnitVentilators->QZnReq -
+                            state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
+                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
+                        mdot = unitVent.MaxHotSteamFlow * PartLoadFrac;
                     }
-                }
+                    
+                    if (QCoilReq < 0.0) QCoilReq = 0.0;
+                    PlantUtilities::SetComponentFlowRate(state, mdot, unitVent.HeatCoilControlNodeNum, unitVent.HeatCoilWaterOutNodeNum, unitVent.HWplantLoc);
+                    SteamCoils::SimulateSteamCoilComponents(
+                        state, unitVent.HeatCoilName, FirstHVACIteration, unitVent.HeatCoilNum, QCoilReq, _, fanOp, PartLoadFrac);
+                } break;
+                  
+                case HVAC::CoilType::HeatingElectric:
+                case HVAC::CoilType::HeatingGasOrOtherFuel: {
+                    if (!state.dataUnitVentilators->HCoilOn) {
+                        QCoilReq = 0.0;
+                    } else {
+                        int HCoilInAirNode = unitVent.FanOutletNode;
+                        Real64 CpAirZn = Psychrometrics::PsyCpAirFnW(state.dataLoopNodes->Node(unitVent.AirInNode).HumRat);
+                        QCoilReq = state.dataUnitVentilators->QZnReq -
+                            state.dataLoopNodes->Node(HCoilInAirNode).MassFlowRate * CpAirZn *
+                            (state.dataLoopNodes->Node(HCoilInAirNode).Temp - state.dataLoopNodes->Node(unitVent.AirInNode).Temp);
+                    }
+                    if (QCoilReq < 0.0) QCoilReq = 0.0;
+                    HeatingCoils::SimulateHeatingCoilComponents(
+                        state, unitVent.HeatCoilName, FirstHVACIteration, QCoilReq, unitVent.HeatCoilNum, _, _, fanOp, PartLoadFrac);
+                } break;
+
+                default: {
+                    assert(false);
+                } break;
+                } // switch ()
             }
         }
         Real64 AirMassFlow = outletNode.MassFlowRate;
diff --git a/src/EnergyPlus/UnitVentilator.hh b/src/EnergyPlus/UnitVentilator.hh
index 78ed98d88ed..8518c9e3901 100644
--- a/src/EnergyPlus/UnitVentilator.hh
+++ b/src/EnergyPlus/UnitVentilator.hh
@@ -69,6 +69,9 @@ struct EnergyPlusData;
 
 namespace UnitVentilator {
 
+    // Current Module Unit type
+    constexpr std::string_view CMO_UnitVentilator = "ZoneHVAC:UnitVentilator";
+
     enum class CoilsUsed
     {
         Invalid = -1,
@@ -78,23 +81,7 @@ namespace UnitVentilator {
         Cooling,
         Num
     };
-    enum class HeatCoilType
-    {
-        Invalid = -1,
-        Electric,
-        Gas,
-        Water,
-        Steam,
-        Num
-    };
-    enum class CoolCoilType
-    {
-        Invalid = -1,
-        Water,
-        Detailed,
-        HXAssisted,
-        Num
-    };
+  
     enum class OAControl
     {
         Invalid = -1,
@@ -134,17 +121,20 @@ namespace UnitVentilator {
         Real64 MinOutAirVolFlow = 0.0;                  // m3/s
         Real64 MinOutAirMassFlow = 0.0;                 // kg/s
         CoilsUsed CoilOption = CoilsUsed::Invalid;      // type of coil option; options are BOTH, HEATING, COOLING, AND NONE
-        bool HCoilPresent = false;                      // .TRUE. if unit ventilator has a heating coil
-        HeatCoilType HCoilType = HeatCoilType::Invalid; // type of heating coil (water, gas, electric, etc.)
-        std::string HCoilName;                          // name of heating coil
-        std::string HCoilTypeCh;                        // type of heating coil character string (same as type on idf file).
-        int HCoil_Index = 0;
-        DataPlant::PlantEquipmentType HeatingCoilType = DataPlant::PlantEquipmentType::Invalid;
 
-        Fluid::RefrigProps *HCoil_fluid = nullptr;
-        Sched::Schedule *hCoilSched = nullptr;
-
-        Real64 HCoilSchedValue = 0.0;
+        bool HeatCoilPresent = false;                      // .TRUE. if unit ventilator has a heating coil
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid; // type of heating coil (water, gas, electric, etc.)
+        std::string HeatCoilName;                          // name of heating coil
+        int HeatCoilNum = 0;
+        DataPlant::PlantEquipmentType HeatCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+        Fluid::RefrigProps *HeatCoilFluid = nullptr;
+        int HeatCoilWaterOutNodeNum = 0;       // outlet of coil
+        int HeatCoilControlNodeNum = 0;          // hot water control node
+        Real64 HeatCoilControlOffset = 0.0;   // control tolerance
+        PlantLocation HWplantLoc;        // index for plant location for hot water coil
+      
+        Real64 HeatCoilSchedVal = 0.0;
+      
         Real64 MaxVolHotWaterFlow = 0.0; // m3/s
         Real64 MaxVolHotSteamFlow = 0.0; // m3/s
         Real64 MaxHotWaterFlow = 0.0;    // kg/s
@@ -153,28 +143,27 @@ namespace UnitVentilator {
         Real64 MinVolHotWaterFlow = 0.0; // m3/s
         Real64 MinVolHotSteamFlow = 0.0; // m3/s
         Real64 MinHotWaterFlow = 0.0;    // kg/s
-        int HotControlNode = 0;          // hot water control node
-        int HotCoilOutNodeNum = 0;       // outlet of coil
-        Real64 HotControlOffset = 0.0;   // control tolerance
-        PlantLocation HWplantLoc;        // index for plant location for hot water coil
-        bool CCoilPresent = false;       // .TRUE. if unit ventilator has a cooling coil
-        std::string CCoilName;           // name of cooling coil
-        std::string CCoilTypeCh;         // type of cooling coil as character string (same as on idf file)
-        int CCoil_Index = 0;
-        std::string CCoilPlantName; // name of cooling coil for plant
-        std::string CCoilPlantType; // type of cooling coil for plant
-        DataPlant::PlantEquipmentType CoolingCoilType = DataPlant::PlantEquipmentType::Invalid;
-        CoolCoilType CCoilType = CoolCoilType::Invalid;
-        Sched::Schedule *cCoilSched = nullptr;
-        Real64 CCoilSchedValue = 0.0;
+
+        bool CoolCoilPresent = false;       // .TRUE. if unit ventilator has a cooling coil
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid;
+        std::string CoolCoilName;           // name of cooling coil
+        int CoolCoilNum = 0;
+        DataPlant::PlantEquipmentType CoolCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+
+        std::string ChildCoolCoilName; // name of child coil if this is an HXAssisted coil
+        HVAC::CoilType ChildCoolCoilType; // name of child coil if this is an HXAssisted coil
+        int ChildCoolCoilNum = 0;
+      
+        Real64 CoolCoilSchedVal = 0.0;
         Real64 MaxVolColdWaterFlow = 0.0; // m3/s
         Real64 MaxColdWaterFlow = 0.0;    // kg/s
         Real64 MinVolColdWaterFlow = 0.0; // m3/s
         Real64 MinColdWaterFlow = 0.0;    // kg/s
-        int ColdControlNode = 0;          // chilled water control node
-        int ColdCoilOutNodeNum = 0;       // chilled water coil out node
-        Real64 ColdControlOffset = 0.0;   // control tolerance
+        int CoolCoilControlNodeNum = 0;          // chilled water control node
+        int CoolCoilWaterOutNodeNum = 0;       // chilled water coil out node
+        Real64 CoolCoilControlOffset = 0.0;   // control tolerance
         PlantLocation CWPlantLoc;         // index for plant component for chilled water coil
+      
         // Report data
         Real64 HeatPower = 0.0;  // unit heating output in watts
         Real64 HeatEnergy = 0.0; // unit heating output in J
@@ -289,9 +278,6 @@ namespace UnitVentilator {
 struct UnitVentilatorsData : BaseGlobalStruct
 {
 
-    // Current Module Unit type
-    std::string const cMO_UnitVentilator = "ZoneHVAC:UnitVentilator";
-
     bool HCoilOn = false;        // TRUE if the heating coil  = gas or electric especially) should be running
     int NumOfUnitVents = 0;      // Number of unit ventilators in the input file
     Real64 OAMassFlowRate = 0.0; // Outside air mass flow rate for the unit ventilator
diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc
index 4946f9269e5..86ed87c78b6 100644
--- a/src/EnergyPlus/UnitarySystem.cc
+++ b/src/EnergyPlus/UnitarySystem.cc
@@ -106,14 +106,6 @@
 namespace EnergyPlus {
 namespace UnitarySystems {
 
-    // Coil type for SimWater and SimSteamCoil
-    int constexpr CoolingCoil = 0;
-    int constexpr HeatingCoil = 1;
-    int constexpr SuppHeatCoil = 2;
-
-    static constexpr std::string_view blankString("");
-    static const std::string blankStdString("");
-
     void UnitarySys::simulate(EnergyPlusData &state,
                               std::string_view Name,
                               bool const FirstHVACIteration,
@@ -409,36 +401,36 @@ namespace UnitarySystems {
                 if (this->m_FanExists && (this->m_CoolCoilExists && (this->m_HeatCoilExists || this->m_SuppCoilExists)))
                     state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySys = true;
                 state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySysSimulating = true;
-                if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
-                    DXCoils::SetCoilSystemCoolingData(state, this->m_CoolingCoilName, this->Name);
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
+                    DXCoils::SetCoilSystemCoolingData(state, this->m_CoolCoilName, this->Name);
                 }
                 // associates an air loop fan on main branch with a coil on main branch where parent does not have a fan
                 if (!this->m_FanExists) {
                     if (state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).supFanType != HVAC::FanType::Invalid) {
                         auto &primaryAirSystems = state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum);
                         if (this->m_CoolCoilExists) {
-                            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
+                            ReportCoilSelection::setCoilSupplyFanInfo(
                                 state,
-                                this->m_CoolingCoilName,
-                                HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num),
+                                this->m_CoolCoilName,
+                                this->m_coolCoilType,
                                 state.dataFans->fans(primaryAirSystems.supFanNum)->Name,
                                 state.dataFans->fans(primaryAirSystems.supFanNum)->type,
                                 primaryAirSystems.supFanNum);
                         }
                         if (this->m_HeatCoilExists) {
-                            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
+                            ReportCoilSelection::setCoilSupplyFanInfo(
                                 state,
-                                this->m_HeatingCoilName,
-                                HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num),
+                                this->m_HeatCoilName,
+                                this->m_heatCoilType,
                                 state.dataFans->fans(primaryAirSystems.supFanNum)->Name,
                                 state.dataFans->fans(primaryAirSystems.supFanNum)->type,
                                 primaryAirSystems.supFanNum);
                         }
                         if (this->m_SuppCoilExists) {
-                            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
+                            ReportCoilSelection::setCoilSupplyFanInfo(
                                 state,
                                 this->m_SuppHeatCoilName,
-                                HVAC::cAllCoilTypes(this->m_SuppHeatCoilType_Num),
+                                this->m_SuppHeatCoilType,
                                 state.dataFans->fans(primaryAirSystems.supFanNum)->Name,
                                 state.dataFans->fans(primaryAirSystems.supFanNum)->type,
                                 primaryAirSystems.supFanNum);
@@ -539,42 +531,35 @@ namespace UnitarySystems {
                     ShowFatalError(state, "InitUnitarySystems: Program terminated for previous conditions.");
                 }
             }
-            DataPlant::PlantEquipmentType TypeOfCoilWaterCooling{DataPlant::PlantEquipmentType::Invalid};
-            if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed ||
-                this->m_CoolingCoilType_Num == HVAC::CoilWater_CoolingHXAssisted) {
-                std::string CoolingCoilType = "";
-                std::string CoolingCoilName = "";
-                if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater) {
-                    TypeOfCoilWaterCooling = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                    CoolingCoilType = "Coil:Cooling:Water";
-                    CoolingCoilName = this->m_CoolingCoilName;
-                } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
-                    TypeOfCoilWaterCooling = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
-                    CoolingCoilType = "Coil:Cooling:Water:DetailedGeometry";
-                    CoolingCoilName = this->m_CoolingCoilName;
-                } else {
-                    TypeOfCoilWaterCooling = static_cast<DataPlant::PlantEquipmentType>(
-                        HVACHXAssistedCoolingCoil::GetCoilObjectTypeNum(state,
-                                                                        HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num),
-                                                                        this->m_CoolingCoilName,
-                                                                        state.dataUnitarySystems->initUnitarySystemsErrFlag,
-                                                                        true));
-                    if (TypeOfCoilWaterCooling == static_cast<DataPlant::PlantEquipmentType>(HVAC::Coil_CoolingWater)) {
-                        TypeOfCoilWaterCooling = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                        CoolingCoilType = "Coil:Cooling:Water";
-                    } else if (TypeOfCoilWaterCooling == static_cast<DataPlant::PlantEquipmentType>(HVAC::Coil_CoolingWaterDetailed)) {
-                        TypeOfCoilWaterCooling = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
-                        CoolingCoilType = "Coil:Cooling:Water:DetailedGeometry";
-                    }
-                    CoolingCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state,
-                                                                                 HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num),
-                                                                                 this->m_CoolingCoilName,
-                                                                                 state.dataUnitarySystems->initUnitarySystemsErrFlag);
-                }
+            
+            DataPlant::PlantEquipmentType coolCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed ||
+                this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {                
+                std::string CoolCoilName = "";
+                int CoolCoilNum = 0;
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingWater) {
+                    coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+                    CoolCoilName = this->m_CoolCoilName;
+                    CoolCoilNum = this->m_CoolCoilNum;
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
+                    coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+                    CoolCoilName = this->m_CoolCoilName;
+                    CoolCoilNum = this->m_CoolCoilNum;
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                    CoolCoilName = this->m_childCoolCoilName;
+                    if (this->m_childCoolCoilType == HVAC::CoilType::CoolingWater) {
+                        coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+                    } else if (this->m_childCoolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
+                        coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+                    }
+                    CoolCoilNum = this->m_childCoolCoilNum;
+                }
+            
                 state.dataUnitarySystems->initUnitarySystemsErrFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        CoolingCoilName,
-                                                        TypeOfCoilWaterCooling,
+                                                        CoolCoilName,
+                                                        coolCoilPlantType,
                                                         this->CoolCoilPlantLoc,
                                                         state.dataUnitarySystems->initUnitarySystemsErrFlag,
                                                         _,
@@ -585,8 +570,7 @@ namespace UnitarySystems {
                 if (state.dataUnitarySystems->initUnitarySystemsErrFlag) {
                     ShowFatalError(state, "InitUnitarySystem: Program terminated for previous conditions.");
                 }
-                this->MaxCoolCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(
-                    state, CoolingCoilType, CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                this->MaxCoolCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, CoolCoilNum);
 
                 if (this->MaxCoolCoilFluidFlow > 0.0) {
                     Real64 rho =
@@ -596,28 +580,21 @@ namespace UnitarySystems {
                 // fill outlet node for coil
                 this->CoolCoilFluidOutletNodeNum = DataPlant::CompData::getPlantComponent(state, this->CoolCoilPlantLoc).NodeNumOut;
             }
-            DataPlant::PlantEquipmentType TypeOfCoilWaterHeating = DataPlant::PlantEquipmentType::Invalid;
-            if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater || this->m_HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
-                std::string HeatingCoilType = "";
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
-                    TypeOfCoilWaterHeating = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-                    HeatingCoilType = "Coil:Heating:Water";
+            DataPlant::PlantEquipmentType heatCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+            if (this->m_heatCoilType == HVAC::CoilType::HeatingWater || this->m_heatCoilType == HVAC::CoilType::HeatingSteam) {
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
+                    heatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
                     // this doesn't work good here, sizing may not have executed yet
                     // air loops seem to work OK, zone equipment not so much, this->m_MaxHeatAirVolFlow = -99999.0
                     // moved to sizing but left this original call
-                    WaterCoils::SetCoilDesFlow(state,
-                                               HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num),
-                                               this->m_HeatingCoilName,
-                                               this->m_MaxHeatAirVolFlow,
-                                               state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                    WaterCoils::SetCoilDesFlow(state, this->m_HeatCoilNum, this->m_MaxHeatAirVolFlow);
                 } else {
-                    TypeOfCoilWaterHeating = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-                    HeatingCoilType = "Coil:Heating:Steam";
+                    heatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
                 }
                 state.dataUnitarySystems->initUnitarySystemsErrFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        this->m_HeatingCoilName,
-                                                        TypeOfCoilWaterHeating,
+                                                        this->m_HeatCoilName,
+                                                        heatCoilPlantType,
                                                         this->HeatCoilPlantLoc,
                                                         state.dataUnitarySystems->initUnitarySystemsErrFlag,
                                                         _,
@@ -628,25 +605,18 @@ namespace UnitarySystems {
                 if (state.dataUnitarySystems->initUnitarySystemsErrFlag) {
                     ShowFatalError(state, "InitUnitarySystem: Program terminated for previous conditions.");
                 }
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
-                    this->MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(
-                        state, HeatingCoilType, this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
+                    this->MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_HeatCoilNum);
 
                     if (this->MaxHeatCoilFluidFlow > 0.0) {
                         Real64 rho = state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum)
                                          .glycol->getDensity(state, Constant::HWInitConvTemp, routineName);
-                        this->MaxHeatCoilFluidFlow =
-                            WaterCoils::GetCoilMaxWaterFlowRate(
-                                state, HeatingCoilType, this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound) *
-                            rho;
+                        this->MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_HeatCoilNum) * rho;
                     }
                 } else {
-                    this->MaxHeatCoilFluidFlow =
-                        SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_HeatingCoilIndex, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                    this->MaxHeatCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_HeatCoilNum);
                     if (this->MaxHeatCoilFluidFlow > 0.0) {
-                        Real64 TempSteamIn = 100.0;
-                        Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, routineName);
-                        this->MaxHeatCoilFluidFlow *= SteamDensity;
+                        this->MaxHeatCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                     }
                 }
                 // fill outlet node for coil
@@ -660,7 +630,7 @@ namespace UnitarySystems {
 
         // Scan Supplemental hot water and steam heating coil plant components for one time initializations
         if (this->m_MySuppCoilPlantScanFlag && allocated(state.dataPlnt->PlantLoop)) {
-            if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingWater) {
                 state.dataUnitarySystems->initUnitarySystemsErrFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
                                                         this->m_SuppHeatCoilName,
@@ -672,30 +642,23 @@ namespace UnitarySystems {
                                                         _,
                                                         _,
                                                         _);
-                WaterCoils::SetCoilDesFlow(state,
-                                           HVAC::cAllCoilTypes(this->m_SuppHeatCoilType_Num),
-                                           this->m_SuppHeatCoilName,
-                                           this->m_MaxHeatAirVolFlow,
-                                           state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+
+                WaterCoils::SetCoilDesFlow(state, this->m_SuppHeatCoilNum, this->m_MaxHeatAirVolFlow);
 
                 if (state.dataUnitarySystems->initUnitarySystemsErrFlag) {
                     ShowFatalError(state, "InitUnitarySystems: Program terminated for previous conditions.");
                 }
-                this->m_MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(
-                    state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                this->m_MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_SuppHeatCoilNum);
 
                 if (this->m_MaxSuppCoilFluidFlow > 0.0) {
                     Real64 rho =
                         state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, routineName);
-                    this->m_MaxSuppCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(
-                            state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound) *
-                        rho;
+                    this->m_MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_SuppHeatCoilNum) * rho;
                 }
                 // fill outlet node for coil
                 this->m_SuppCoilFluidOutletNodeNum = DataPlant::CompData::getPlantComponent(state, this->m_SuppCoilPlantLoc).NodeNumOut;
 
-            } else if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+            } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                 state.dataUnitarySystems->initUnitarySystemsErrFlag = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
                                                         this->m_SuppHeatCoilName,
@@ -710,12 +673,9 @@ namespace UnitarySystems {
                 if (state.dataUnitarySystems->initUnitarySystemsErrFlag) {
                     ShowFatalError(state, "InitUnitarySystems: Program terminated for previous conditions.");
                 }
-                this->m_MaxSuppCoilFluidFlow =
-                    SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_SuppHeatCoilIndex, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                this->m_MaxSuppCoilFluidFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_SuppHeatCoilNum);
                 if (this->m_MaxSuppCoilFluidFlow > 0.0) {
-                    Real64 TempSteamIn = 100.0;
-                    Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, routineName);
-                    this->m_MaxSuppCoilFluidFlow *= SteamDensity;
+                    this->m_MaxSuppCoilFluidFlow *= Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                 }
 
                 // fill outlet node for coil
@@ -765,15 +725,8 @@ namespace UnitarySystems {
 
                 if (this->MaxCoolCoilFluidFlow == DataSizing::AutoSize) {
                     // If water coil max water flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
-                    std::string CoolingCoilType = "";
-                    if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater) {
-                        CoolingCoilType = "Coil:Cooling:Water";
-                    } else {
-                        CoolingCoilType = "Coil:Cooling:Water:DetailedGeometry";
-                    }
-                    WaterCoils::SimulateWaterCoilComponents(state, this->m_CoolingCoilName, FirstHVACIteration, this->m_CoolingCoilIndex);
-                    Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(
-                        state, CoolingCoilType, this->m_CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                    WaterCoils::SimulateWaterCoilComponents(state, this->m_CoolCoilName, FirstHVACIteration, this->m_CoolCoilNum);
+                    Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_CoolCoilNum);
                     if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                         Real64 rho = state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum)
                                          .glycol->getDensity(state, Constant::CWInitConvTemp, routineName);
@@ -788,10 +741,9 @@ namespace UnitarySystems {
 
                 if (this->MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
                     // IF water coil max water flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
-                        WaterCoils::SimulateWaterCoilComponents(state, this->m_HeatingCoilName, FirstHVACIteration, this->m_HeatingCoilIndex);
-                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(
-                            state, "Coil:Heating:Water", this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
+                        WaterCoils::SimulateWaterCoilComponents(state, this->m_HeatCoilName, FirstHVACIteration, this->m_HeatCoilNum);
+                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                             Real64 rho = state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum)
                                              .glycol->getDensity(state, Constant::CWInitConvTemp, routineName);
@@ -799,20 +751,17 @@ namespace UnitarySystems {
                         }
                     }
                     // If steam coil max steam flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
+                    else if (this->m_heatCoilType == HVAC::CoilType::HeatingSteam) {
                         SteamCoils::SimulateSteamCoilComponents(
                             state,
-                            this->m_HeatingCoilName,
+                            this->m_HeatCoilName,
                             FirstHVACIteration,
-                            this->m_HeatingCoilIndex,
+                            this->m_HeatCoilNum,
                             1.0,
                             state.dataUnitarySystems->initUnitarySystemsQActual); // QCoilReq, simulate any load > 0 to get max capacity
-                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(
-                            state, this->m_HeatingCoilIndex, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            Real64 TempSteamIn = 100.0;
-                            Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, routineName);
-                            this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;
+                            this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                         }
                     }
                 }
@@ -822,31 +771,27 @@ namespace UnitarySystems {
             }
             if (this->m_SuppCoilFluidInletNode > 0) {
                 if (this->m_MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
-                    if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+                    if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingWater) {
                         // If water coil max water flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
-                        WaterCoils::SimulateWaterCoilComponents(state, this->m_SuppHeatCoilName, FirstHVACIteration, this->m_SuppHeatCoilIndex);
-                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(
-                            state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                        WaterCoils::SimulateWaterCoilComponents(state, this->m_SuppHeatCoilNum, FirstHVACIteration);
+                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_SuppHeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                             Real64 rho = state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum)
                                              .glycol->getDensity(state, Constant::CWInitConvTemp, routineName);
                             this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho;
                         }
                     }
-                    if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+                    if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                         SteamCoils::SimulateSteamCoilComponents(
                             state,
                             this->m_SuppHeatCoilName,
                             FirstHVACIteration,
-                            this->m_SuppHeatCoilIndex,
+                            this->m_SuppHeatCoilNum,
                             1.0,
                             state.dataUnitarySystems->initUnitarySystemsQActual); // QCoilReq, simulate any load > 0 to get max capacity
-                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(
-                            state, this->m_SuppHeatCoilIndex, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_SuppHeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            Real64 TempSteamIn = 100.0;
-                            Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, routineName);
-                            this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;
+                            this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                         }
                     }
                     PlantUtilities::InitComponentNodes(
@@ -927,7 +872,9 @@ namespace UnitarySystems {
                     }
                 }
             }
-            if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
+            
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
 
                 //     set water-side mass flow rates
                 Real64 mdot = this->MaxCoolCoilFluidFlow;
@@ -935,14 +882,15 @@ namespace UnitarySystems {
                     state, mdot, this->CoolCoilFluidInletNode, this->CoolCoilFluidOutletNodeNum, this->CoolCoilPlantLoc);
                 //     simulate water coil to find operating capacity
                 WaterCoils::SimulateWaterCoilComponents(state,
-                                                        this->m_CoolingCoilName,
+                                                        this->m_CoolCoilName,
                                                         FirstHVACIteration,
-                                                        this->m_CoolingCoilIndex,
+                                                        this->m_CoolCoilNum,
                                                         state.dataUnitarySystems->initUnitarySystemsQActual);
                 this->m_DesignCoolingCapacity = state.dataUnitarySystems->initUnitarySystemsQActual;
 
             } // from IF(UnitarySystem(UnitarySysNum)%CoolingCoilType_Num == Coil_CoolingWater .OR. Coil_CoolingWaterDetailed
-            if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
+
+            if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
 
                 //     set water-side mass flow rates
                 Real64 mdot = this->MaxHeatCoilFluidFlow;
@@ -950,15 +898,15 @@ namespace UnitarySystems {
                     state, mdot, this->HeatCoilFluidInletNode, this->HeatCoilFluidOutletNodeNum, this->HeatCoilPlantLoc);
                 //     simulate water coil to find operating capacity
                 WaterCoils::SimulateWaterCoilComponents(state,
-                                                        this->m_HeatingCoilName,
+                                                        this->m_HeatCoilName,
                                                         FirstHVACIteration,
-                                                        this->m_HeatingCoilIndex,
+                                                        this->m_HeatCoilNum,
                                                         state.dataUnitarySystems->initUnitarySystemsQActual);
                 this->m_DesignHeatingCapacity = state.dataUnitarySystems->initUnitarySystemsQActual;
 
             } // from IF(UnitarySystem(UnitarySysNum)%HeatingCoilType_Num == Coil_HeatingWater) THEN
 
-            if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
+            if (this->m_heatCoilType == HVAC::CoilType::HeatingSteam) {
 
                 //     set water-side mass flow rates
                 Real64 mdot = this->MaxHeatCoilFluidFlow;
@@ -967,19 +915,14 @@ namespace UnitarySystems {
                 //     simulate steam coil to find operating capacity
                 SteamCoils::SimulateSteamCoilComponents(
                     state,
-                    this->m_HeatingCoilName,
+                    this->m_HeatCoilName,
                     FirstHVACIteration,
-                    this->m_HeatingCoilIndex,
+                    this->m_HeatCoilNum,
                     1.0,
                     state.dataUnitarySystems->initUnitarySystemsQActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                this->m_DesignHeatingCapacity = SteamCoils::GetCoilCapacity(state,
-                                                                            HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num),
-                                                                            this->m_HeatingCoilName,
-                                                                            state.dataUnitarySystems->initUnitarySystemsErrorsFound);
-
-            } // from IF(UnitarySystem(UnitarySysNum)%HeatingCoilType_Num == Coil_HeatingSteam) THEN
-            if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+                this->m_DesignHeatingCapacity = SteamCoils::GetCoilCapacity(state, this->m_HeatCoilNum);
 
+            } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingWater) {
                 //     set steam-side mass flow rates
                 Real64 mdot = this->m_MaxSuppCoilFluidFlow;
                 PlantUtilities::SetComponentFlowRate(
@@ -990,7 +933,7 @@ namespace UnitarySystems {
                     WaterCoils::SimulateWaterCoilComponents(state,
                                                             this->m_SuppHeatCoilName,
                                                             FirstHVACIteration,
-                                                            this->m_SuppHeatCoilIndex,
+                                                            this->m_SuppHeatCoilNum,
                                                             state.dataUnitarySystems->initUnitarySystemsQActual);
                     this->m_DesignSuppHeatingCapacity = state.dataUnitarySystems->initUnitarySystemsQActual;
                 } else {
@@ -999,24 +942,6 @@ namespace UnitarySystems {
 
             } // from IF(UnitarySystem(UnitarySysNum)%SuppHeatCoilType_Num == Coil_HeatingWater) THEN
 
-            if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
-
-                //     set air-side and steam-side mass flow rates
-                Real64 mdot = this->m_MaxSuppCoilFluidFlow;
-                PlantUtilities::SetComponentFlowRate(
-                    state, mdot, this->m_SuppCoilFluidInletNode, this->m_SuppCoilFluidOutletNodeNum, this->m_SuppCoilPlantLoc);
-                //     simulate steam coil to find operating capacity
-                SteamCoils::SimulateSteamCoilComponents(
-                    state,
-                    this->m_SuppHeatCoilName,
-                    FirstHVACIteration,
-                    this->m_SuppHeatCoilIndex,
-                    1.0,
-                    state.dataUnitarySystems->initUnitarySystemsQActual); // QCoilReq, simulate any load > 0 to get max capacity of steam coil
-                this->m_DesignSuppHeatingCapacity = SteamCoils::GetCoilCapacity(
-                    state, "Coil:Heating:Steam", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound);
-
-            } // from IF(UnitarySystem(UnitarySysNum)%SuppHeatCoilType_Num == Coil_HeatingSteam) THEN
         }     // from IF( FirstHVACIteration ) THEN
 
         this->m_IterationCounter += 1;
@@ -1024,9 +949,9 @@ namespace UnitarySystems {
         if (this->m_MySetPointCheckFlag) {
             if (!state.dataGlobal->SysSizingCalc && state.dataHVACGlobal->DoSetPointTest) {
                 bool e = false;
-                if (this->m_CoolCoilExists) e = this->checkNodeSetPoint(state, AirLoopNum, this->CoolCtrlNode, CoolingCoil, OAUCoilOutTemp);
-                if (this->m_HeatCoilExists) e = this->checkNodeSetPoint(state, AirLoopNum, this->HeatCtrlNode, HeatingCoil, OAUCoilOutTemp) || e;
-                if (this->m_SuppCoilExists) e = this->checkNodeSetPoint(state, AirLoopNum, this->SuppCtrlNode, SuppHeatCoil, OAUCoilOutTemp) || e;
+                if (this->m_CoolCoilExists) e = this->checkNodeSetPoint(state, AirLoopNum, this->CoolCtrlNode, WhichCoil::Cool, OAUCoilOutTemp);
+                if (this->m_HeatCoilExists) e = this->checkNodeSetPoint(state, AirLoopNum, this->HeatCtrlNode, WhichCoil::Heat, OAUCoilOutTemp) || e;
+                if (this->m_SuppCoilExists) e = this->checkNodeSetPoint(state, AirLoopNum, this->SuppCtrlNode, WhichCoil::SuppHeat, OAUCoilOutTemp) || e;
                 if (e) ShowFatalError(state, "Previous errors cause termination.");
                 this->m_MySetPointCheckFlag = false;
             }
@@ -1036,8 +961,8 @@ namespace UnitarySystems {
             if ((!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) && (!state.dataGlobal->KickOffSimulation)) {
 
                 // check FaultsManager if connection exists
-                FaultsManager::SetFaultyCoilSATSensor(state, this->UnitType, this->Name, this->m_FaultyCoilSATFlag, this->m_FaultyCoilSATIndex);
-                if (this->m_FaultyCoilSATFlag) {
+                this->m_FaultyCoilSATIndex = FaultsManager::GetFaultyCoilSATIndex(state, this->Name);
+                if (this->m_FaultyCoilSATIndex > 0) {
                     if (this->m_ControlType != UnitarySysCtrlType::Setpoint) {
                         ShowWarningError(state,
                                          format("{}: {}",
@@ -1047,7 +972,7 @@ namespace UnitarySystems {
                         ShowContinueError(state,
                                           "The specified unitary system is not controlled on leaving air temperature. The coil SAT sensor "
                                           "fault model will not be applied.");
-                        this->m_FaultyCoilSATFlag = false;
+                        this->m_FaultyCoilSATIndex = 0;
                     }
                 }
                 m_setFaultModelInput = false;
@@ -1139,7 +1064,7 @@ namespace UnitarySystems {
     bool UnitarySys::checkNodeSetPoint(EnergyPlusData &state,
                                        int const AirLoopNum,       // number of the current air loop being simulated
                                        int const ControlNode,      // Node to test for set point
-                                       int const CoilType,         // True if cooling coil, then test for HumRatMax set point
+                                       WhichCoil const whichCoil,         // True if cooling coil, then test for HumRatMax set point
                                        Real64 const OAUCoilOutTemp // the coil inlet temperature of OutdoorAirUnit
     )
     {
@@ -1150,20 +1075,20 @@ namespace UnitarySystems {
 
         // PURPOSE OF THIS SUBROUTINE:
         // This subroutine checks for proper set point at control node.
-        constexpr static std::array<std::string_view, 3> coilTypes = {"cooling", "heating", "supplemental"};
+        constexpr static std::array<std::string_view, (int)WhichCoil::Num> whichCoilNames = {"cooling", "heating", "supplemental"};
         bool SetPointErrorFlag = false;
 
         if (ControlNode == 0) {
             if (this->m_ControlType == UnitarySysCtrlType::Setpoint) {
                 int coilOutNode = this->CoolCoilOutletNodeNum;
-                if (CoilType == HeatingCoil) coilOutNode = this->HeatCoilOutletNodeNum;
-                if (CoilType == SuppHeatCoil) coilOutNode = this->SuppCoilOutletNodeNum;
+                if (whichCoil == WhichCoil::Heat) coilOutNode = this->HeatCoilOutletNodeNum;
+                if (whichCoil == WhichCoil::SuppHeat) coilOutNode = this->SuppCoilOutletNodeNum;
 
-                ShowSevereError(state, format("checkNodeSetPoint: Missing {} set point in {} = {}", coilTypes[CoilType], this->UnitType, this->Name));
+                ShowSevereError(state, format("checkNodeSetPoint: Missing {} set point in {} = {}", whichCoilNames[(int)whichCoil], this->UnitType, this->Name));
                 ShowContinueError(state,
                                   format("...Setpoint is required at system air outlet node = {} or {} coil air outlet node = {}",
                                          state.dataLoopNodes->NodeID(this->AirOutNode),
-                                         coilTypes[CoilType],
+                                         whichCoilNames[(int)whichCoil],
                                          state.dataLoopNodes->NodeID(coilOutNode)));
                 SetPointErrorFlag = true;
             }
@@ -1199,7 +1124,7 @@ namespace UnitarySystems {
             }
             if ((this->m_DehumidControlType_Num != DehumCtrlType::None) &&
                 (state.dataLoopNodes->Node(ControlNode).HumRatMax == DataLoopNode::SensedNodeFlagValue) &&
-                this->m_ControlType == UnitarySysCtrlType::Setpoint && CoilType == CoolingCoil) {
+                this->m_ControlType == UnitarySysCtrlType::Setpoint && whichCoil == WhichCoil::Cool) {
                 if (!state.dataGlobal->AnyEnergyManagementSystemInModel &&
                     state.dataLoopNodes->Node(this->CoolCoilOutletNodeNum).HumRatMax == DataLoopNode::SensedNodeFlagValue) {
                     ShowSevereError(state,
@@ -1376,8 +1301,9 @@ namespace UnitarySystems {
             state.dataHVACGlobal->DXCT = HVAC::DXCoilType::Regular; // uses normal DX coil flow limits
         }
         // sizing may need to know what type of coil is being sized
-        state.dataSize->DataCoolCoilType = this->m_CoolingCoilType_Num;
-        state.dataSize->DataCoolCoilIndex = this->m_CoolingCoilIndex;
+        state.dataSize->DataCoolCoilType = this->m_coolCoilType;
+        state.dataSize->DataCoolCoilIndex = this->m_CoolCoilNum;
+        
 
         bool anyEMSRan;
         EMSManager::ManageEMS(state, EMSManager::EMSCallFrom::UnitarySystemSizing, anyEMSRan, ObjexxFCL::Optional_int_const()); // calling point
@@ -1510,15 +1436,15 @@ namespace UnitarySystems {
                     sizingCoolingAirFlow.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
                     state.dataSize->DataFlowUsedForSizing = sizingCoolingAirFlow.size(state, TempSize, errorsFound);
                     SizingMethod = HVAC::CoolingCapacitySizing;
-                    if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) {
                         state.dataSize->DataTotCapCurveIndex =
-                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getOpModeCapFTIndex(HVAC::CoilMode::Normal);
+                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].getOpModeCapFTIndex(HVAC::CoilMode::Normal);
                         state.dataSize->DataIsDXCoil = true;
-                    } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed ||
-                               this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling ||
-                               this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-                               this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                        state.dataSize->DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                               this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                               this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+                               this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                        state.dataSize->DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                         state.dataSize->DataIsDXCoil = true;
                     }
                     CoolingCapacitySizer sizerCoolingCapacity;
@@ -1551,25 +1477,25 @@ namespace UnitarySystems {
                 state.dataSize->DataFlowUsedForSizing = EqSizing.CoolingAirVolFlow;
                 TempSize = DataSizing::AutoSize;
                 // could probably move this up outside the IF and delete then next group below in the else
-                switch (this->m_CoolingCoilType_Num) {
-                case HVAC::CoilDX_Cooling: {
+                switch (this->m_coolCoilType) {
+                case HVAC::CoilType::CoolingDX: {
                     state.dataSize->DataTotCapCurveIndex =
-                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getOpModeCapFTIndex(HVAC::CoilMode::Normal);
+                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].getOpModeCapFTIndex(HVAC::CoilMode::Normal);
                     state.dataSize->DataIsDXCoil = true;
                 } break;
-                case HVAC::CoilDX_CoolingSingleSpeed:
-                case HVAC::CoilDX_MultiSpeedCooling:
-                case HVAC::CoilDX_CoolingTwoSpeed:
-                case HVAC::CoilDX_CoolingTwoStageWHumControl: {
-                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+                case HVAC::CoilType::CoolingDXSingleSpeed:
+                case HVAC::CoilType::CoolingDXMultiSpeed:
+                case HVAC::CoilType::CoolingDXTwoSpeed:
+                case HVAC::CoilType::CoolingDXTwoStageWHumControl: {
+                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                     state.dataSize->DataIsDXCoil = true;
                 } break;
-                case HVAC::Coil_CoolingAirToAirVariableSpeed: {
-                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetVSCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+                case HVAC::CoilType::CoolingDXVariableSpeed: {
+                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                     state.dataSize->DataIsDXCoil = true;
                 } break;
-                case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
-                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetVSCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+                case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
+                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                     // VS coil model does not check for flow/capacity ratio, this will disable that test in Capacity sizer
                     // state.dataSize->DataIsDXCoil = true;
                 } break;
@@ -1591,18 +1517,19 @@ namespace UnitarySystems {
                 }
             } else if (!HardSizeNoDesRun && (CoolingSAFlowMethod != DataSizing::FlowPerCoolingCapacity && this->m_DesignCoolingCapacity > 0.0)) {
                 // corrected code for #8756
-                if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling ||
-                    this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-                    this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                    this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                    this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+                    this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                     state.dataSize->DataIsDXCoil = true;
-                }
-                if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetVSCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                     state.dataSize->DataIsDXCoil = true;
-                }
-                if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
-                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetVSCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
+                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                     // VS coil model does not check for flow/capacity ratio, this will disable that test in Capacity sizer
                     // state.dataSize->DataIsDXCoil = true;
                 }
@@ -1676,8 +1603,10 @@ namespace UnitarySystems {
                 SizingMethod = HVAC::HeatingCapacitySizing;
                 state.dataSize->DataFracOfAutosizedCoolingCapacity = 1.0;
                 state.dataSize->DataHeatSizeRatio = this->m_HeatingSizingRatio;
-                if (this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating || this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(state, this->m_HeatingCoilIndex, ErrFound);
+
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed ||
+                    this->m_heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
+                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(state, this->m_HeatCoilNum);
                     state.dataSize->DataIsDXCoil = true;
                 }
                 if (state.dataSize->CurSysNum > 0)
@@ -1710,13 +1639,14 @@ namespace UnitarySystems {
                 }
                 TempSize = DataSizing::AutoSize;
                 state.dataSize->DataHeatSizeRatio = this->m_HeatingSizingRatio;
-                if (this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical || this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
-                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(state, this->m_HeatingCoilIndex, ErrFound);
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+                    this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+                    state.dataSize->DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(state, this->m_HeatCoilNum);
                     state.dataSize->DataIsDXCoil = true;
                 }
                 // should have VS coil capFT here also
-                if (this->m_sysType == SysType::PackagedWSHP && this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
-                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetVSCoilCapFTCurveIndex(state, this->m_CoolingCoilIndex, ErrFound);
+                if (this->m_sysType == SysType::PackagedWSHP && this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
+                    state.dataSize->DataTotCapCurveIndex = VariableSpeedCoils::GetCoilCapFTCurve(state, this->m_CoolCoilNum);
                     // VS coil model does not check for flow/capacity ratio, this will disable that test in Capacity sizer
                     // state.dataSize->DataIsDXCoil = true;
                 }
@@ -1739,12 +1669,12 @@ namespace UnitarySystems {
                 if (!HardSizeNoDesRun &&
                     (HeatingSAFlowMethod != DataSizing::FlowPerHeatingCapacity && this->m_DesignHeatingCapacity != DataSizing::AutoSize)) {
                     // should have other DX heating coil types here
-                    if (this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                         SizingMethod = HVAC::HeatingCapacitySizing;
                         state.dataSize->DataFlowUsedForSizing = EqSizing.HeatingAirVolFlow;
                         TempSize = DataSizing::AutoSize;
                         state.dataSize->DataHeatSizeRatio = this->m_HeatingSizingRatio;
-                        state.dataSize->DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(state, this->m_HeatingCoilIndex, ErrFound);
+                        state.dataSize->DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(state, this->m_HeatCoilNum);
                         state.dataSize->DataIsDXCoil = true;
                         if (state.dataSize->CurSysNum > 0)
                             state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySysSimulating =
@@ -1770,34 +1700,34 @@ namespace UnitarySystems {
             if (this->m_sysType == SysType::PackagedAC) EqSizing.HeatingCapacity = false;
         }
 
-        bool isWSVarSpeedCoolCoil = this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
-        bool isWSVarSpeedHeatCoil = this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit;
-        bool isVarSpeedCoolCoil = this->m_HeatingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed;
-        bool isVarSpeedHeatCoil = this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed;
+        bool isWSVarSpeedCoolCoil = this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit;
+        bool isWSVarSpeedHeatCoil = this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit;
+        bool isVarSpeedCoolCoil = this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed; // this was heatCoilType
+        bool isVarSpeedHeatCoil = this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed;
 
         Real64 saveRawHeatingCapacity = HeatCapAtPeak;
 
         // STEP 3A: Find VS cooling coil air flow to capacity ratio and adjust design air flow
         if (EqSizing.DesCoolingLoad > 0.0 && state.dataSize->CurZoneEqNum > 0 &&
-            (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
+            (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
              ((this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP) &&
-              this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed))) {
+              this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed))) {
             Real64 coolingToHeatingCapRatio = 1.0;
             if ((isWSVarSpeedCoolCoil && this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) ||
                 ((this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP) &&
-                 this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
-                int normSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).NormSpedLevel;
+                 this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed)) {
+                int normSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).NormSpedLevel;
                 Real64 coolingAirFlowToCapacityRatio =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowPerRatedTotCap(normSpeed);
+                    state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).MSRatedAirVolFlowPerRatedTotCap(normSpeed);
                 EqSizing.CoolingAirVolFlow = EqSizing.DesCoolingLoad * coolingAirFlowToCapacityRatio;
                 if (EqSizing.DesHeatingLoad > 0.0) coolingToHeatingCapRatio = EqSizing.DesCoolingLoad / EqSizing.DesHeatingLoad;
             }
             if (((isWSVarSpeedHeatCoil || isVarSpeedHeatCoil) && this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) ||
                 ((this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP) &&
-                 this->m_CoolingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
-                int normSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).NumOfSpeeds;
+                 this->m_coolCoilType == HVAC::CoilType::HeatingDXVariableSpeed)) {
+                int normSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).NumOfSpeeds;
                 Real64 heatingAirFlowToCapacityRatio =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowPerRatedTotCap(normSpeed);
+                    state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).MSRatedAirVolFlowPerRatedTotCap(normSpeed);
                 EqSizing.DesHeatingLoad *= coolingToHeatingCapRatio;
                 EqSizing.HeatingAirVolFlow = EqSizing.DesHeatingLoad * heatingAirFlowToCapacityRatio;
             }
@@ -1814,9 +1744,10 @@ namespace UnitarySystems {
              (((this->m_sysType == SysType::PackagedAC && !isVarSpeedCoolCoil) && (this->m_sysType == SysType::PackagedHP && !isVarSpeedHeatCoil)) ||
               (this->m_sysType == SysType::Unitary && this->m_HeatPump))) ||
             (this->m_sysType == SysType::Unitary &&
-             (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted || this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling ||
-              this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed ||
-              this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling))) {
+             (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted ||
+              this->m_coolCoilType == HVAC::CoilType::CoolingDX ||
+              this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+              this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed))) {
             EqSizing.CoolingAirVolFlow = max(EqSizing.CoolingAirVolFlow, EqSizing.HeatingAirVolFlow);
             EqSizing.HeatingAirVolFlow = EqSizing.CoolingAirVolFlow;
         }
@@ -1830,8 +1761,8 @@ namespace UnitarySystems {
         } else if (this->m_HeatPump && (state.dataSize->CurZoneEqNum == 0 || !isWSVarSpeedCoolCoil)) {
             EqSizing.AirFlow = true;
             EqSizing.AirVolFlow = max(EqSizing.CoolingAirVolFlow, EqSizing.HeatingAirVolFlow);
-            if (this->m_CoolingCoilType_Num != HVAC::Coil_CoolingWaterToAirHPVSEquationFit &&
-                this->m_HeatingCoilType_Num != HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+            if (this->m_coolCoilType != HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit &&
+                this->m_heatCoilType != HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                 EqSizing.Capacity = true;
                 EqSizing.DesCoolingLoad = max(EqSizing.DesCoolingLoad, EqSizing.DesHeatingLoad);
                 EqSizing.DesHeatingLoad = EqSizing.DesCoolingLoad;
@@ -1919,7 +1850,7 @@ namespace UnitarySystems {
                     this->m_MaxHeatAirVolFlow = DataSizing::AutoSize;
                 }
                 bool saveEqSizingAirFlow = EqSizing.AirFlow;
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                     EqSizing.AirFlow = false;
                 }
                 FieldNum = 7; // N7 , \field Heating Supply Air Flow Rate
@@ -1936,7 +1867,7 @@ namespace UnitarySystems {
                 this->m_MaxHeatAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
                 state.dataSize->DataEMSOverrideON = false;
                 state.dataSize->DataConstantUsedForSizing = 0.0;
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                     EqSizing.AirFlow = saveEqSizingAirFlow;
                 }
             }
@@ -1949,7 +1880,7 @@ namespace UnitarySystems {
                     this->m_MaxHeatAirVolFlow = DataSizing::AutoSize;
                 }
                 bool saveEqSizingAirFlow = EqSizing.AirFlow;
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                     EqSizing.AirFlow = false;
                 }
                 FieldNum = 7; // N7 , \field Heating Supply Air Flow Rate
@@ -1966,7 +1897,7 @@ namespace UnitarySystems {
                 this->m_MaxHeatAirVolFlow = sizingHeatingAirFlow.size(state, TempSize, errorsFound);
                 state.dataSize->DataEMSOverrideON = false;
                 state.dataSize->DataConstantUsedForSizing = 0.0;
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                     EqSizing.AirFlow = saveEqSizingAirFlow;
                 }
             }
@@ -2035,80 +1966,80 @@ namespace UnitarySystems {
                 }
             } else {
                 if ((this->m_CoolCoilExists || this->m_HeatCoilExists) && this->m_useNoLoadLowSpeedAirFlow) {
-                    if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed ||
-                        this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                        this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
                         Real64 MaxSpeedFlowRate =
-                            state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex)
-                                .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).NumOfSpeeds);
-                        if (MaxSpeedFlowRate > 0.0 && state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(1) >
+                            state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum)
+                                .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).NumOfSpeeds);
+                        if (MaxSpeedFlowRate > 0.0 && state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(1) >
                                                           0.0) { // these are the air flow at speed fields, and could be 0
                             NoLoadCoolingAirFlowRateRatio =
-                                state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
+                                state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
                         } else {
-                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).NumOfSpeeds;
+                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).NumOfSpeeds;
                         }
-                    } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                         // for (DehumidModeNum = 0; DehumidModeNum <= thisDXCoil.NumDehumidModes; ++DehumidModeNum)
                         // for (CapacityStageNum = 1; CapacityStageNum <= thisDXCoil.NumCapacityStages; ++CapacityStageNum)
                         // PerfModeNum = DehumidModeNum * 2 + CapacityStageNum
                         // RatedAirVolFlowRate(PerfModeNum) so PerfModeNum = 1 to NumCapacityStages to find air flow rate
-                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex)
-                                                      .RatedAirVolFlowRate(state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).NumCapacityStages);
+                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_CoolCoilNum)
+                                                      .RatedAirVolFlowRate(state.dataDXCoils->DXCoil(this->m_CoolCoilNum).NumCapacityStages);
                         if (MaxSpeedFlowRate > 0.0 &&
-                            state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).RatedAirVolFlowRate(1) != DataSizing::AutoSize) {
+                            state.dataDXCoils->DXCoil(this->m_CoolCoilNum).RatedAirVolFlowRate(1) != DataSizing::AutoSize) {
                             NoLoadCoolingAirFlowRateRatio =
-                                state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).RatedAirVolFlowRate(1) / MaxSpeedFlowRate;
+                                state.dataDXCoils->DXCoil(this->m_CoolCoilNum).RatedAirVolFlowRate(1) / MaxSpeedFlowRate;
                         } else { // if any flow rates are autosized use the ratio of number of capacity stages
-                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).NumCapacityStages;
+                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataDXCoils->DXCoil(this->m_CoolCoilNum).NumCapacityStages;
                         }
-                    } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                         // RatedAirVolFlowRate(1) = high speed, RatedAirVolFlowRate2= low speed
-                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).RatedAirVolFlowRate(1);
+                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_CoolCoilNum).RatedAirVolFlowRate(1);
                         if (MaxSpeedFlowRate > 0.0 &&
-                            state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).RatedAirVolFlowRate2 != DataSizing::AutoSize) {
+                            state.dataDXCoils->DXCoil(this->m_CoolCoilNum).RatedAirVolFlowRate2 != DataSizing::AutoSize) {
                             NoLoadCoolingAirFlowRateRatio =
-                                state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).RatedAirVolFlowRate2 / MaxSpeedFlowRate;
+                                state.dataDXCoils->DXCoil(this->m_CoolCoilNum).RatedAirVolFlowRate2 / MaxSpeedFlowRate;
                         } else { // above flow rates for this coil could be autosized, use 1/2 for two speed coil
                             NoLoadCoolingAirFlowRateRatio = 0.5;
                         }
-                    } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
                         // MSRatedAirVolFlowRate
-                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex)
-                                                      .MSRatedAirVolFlowRate(state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).NumOfSpeeds);
+                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_CoolCoilNum)
+                                                      .MSRatedAirVolFlowRate(state.dataDXCoils->DXCoil(this->m_CoolCoilNum).NumOfSpeeds);
                         if (MaxSpeedFlowRate > 0.0 &&
-                            state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(1) != DataSizing::AutoSize) {
+                            state.dataDXCoils->DXCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(1) != DataSizing::AutoSize) {
                             NoLoadCoolingAirFlowRateRatio =
-                                state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
+                                state.dataDXCoils->DXCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
                         } else { // if any flow rates are autosized use the ratio of number of speeds
-                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).NumOfSpeeds;
+                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataDXCoils->DXCoil(this->m_CoolCoilNum).NumOfSpeeds;
                         }
-                    } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
-                        NoLoadCoolingAirFlowRateRatio = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex]
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) {
+                        NoLoadCoolingAirFlowRateRatio = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum]
                                                             .performance.normalMode.speeds[0]
                                                             .original_input_specs.evaporator_air_flow_fraction;
                     }
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed ||
+                        this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                         Real64 MaxSpeedFlowRate =
-                            state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex)
-                                .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).NumOfSpeeds);
-                        if (MaxSpeedFlowRate > 0.0 && state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(1) >
+                            state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum)
+                                .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).NumOfSpeeds);
+                        if (MaxSpeedFlowRate > 0.0 && state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).MSRatedAirVolFlowRate(1) >
                                                           0.0) { // these are the air flow at speed fields, and could be 0
                             NoLoadHeatingAirFlowRateRatio =
-                                state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
+                                state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
                         } else {
-                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).NumOfSpeeds;
+                            NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).NumOfSpeeds;
                         }
-                    } else if (this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+                    } else if (this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                         // MSRatedAirVolFlowRate
-                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_HeatingCoilIndex)
-                                                      .MSRatedAirVolFlowRate(state.dataDXCoils->DXCoil(this->m_HeatingCoilIndex).NumOfSpeeds);
+                        Real64 MaxSpeedFlowRate = state.dataDXCoils->DXCoil(this->m_HeatCoilNum)
+                                                      .MSRatedAirVolFlowRate(state.dataDXCoils->DXCoil(this->m_HeatCoilNum).NumOfSpeeds);
                         if (MaxSpeedFlowRate > 0.0 &&
-                            state.dataDXCoils->DXCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(1) != DataSizing::AutoSize) {
+                            state.dataDXCoils->DXCoil(this->m_HeatCoilNum).MSRatedAirVolFlowRate(1) != DataSizing::AutoSize) {
                             NoLoadHeatingAirFlowRateRatio =
-                                state.dataDXCoils->DXCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
+                                state.dataDXCoils->DXCoil(this->m_HeatCoilNum).MSRatedAirVolFlowRate(1) / MaxSpeedFlowRate;
                         } else { // if any flow rates are autosized use the ratio of number of speeds
-                            NoLoadHeatingAirFlowRateRatio = 1.0 / state.dataDXCoils->DXCoil(this->m_HeatingCoilIndex).NumOfSpeeds;
+                            NoLoadHeatingAirFlowRateRatio = 1.0 / state.dataDXCoils->DXCoil(this->m_HeatCoilNum).NumOfSpeeds;
                         }
                     }
                     this->m_NoLoadAirFlowRateRatio = min(NoLoadCoolingAirFlowRateRatio, NoLoadHeatingAirFlowRateRatio);
@@ -2117,8 +2048,8 @@ namespace UnitarySystems {
             if (this->m_NoCoolHeatSAFMethod <= DataSizing::SupplyAirFlowRate && this->m_ControlType == UnitarySysCtrlType::CCMASHRAE) {
                 if (this->m_MaxNoCoolHeatAirVolFlow == DataSizing::AutoSize) {
                     state.dataSize->DataConstantUsedForSizing = max(this->m_MaxCoolAirVolFlow, this->m_MaxHeatAirVolFlow);
-                    if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+                        this->m_heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
                         minNoLoadFlow = 0.6667; // TODO: Should this have a Coil:Cooling:DX block?
                     } else {
                         if (this->m_NoLoadAirFlowRateRatio < 1.0) {
@@ -2151,11 +2082,10 @@ namespace UnitarySystems {
             } else if (this->m_NoCoolHeatSAFMethod == DataSizing::FlowPerCoolingCapacity) {
                 if (EqSizing.DesCoolingLoad <= 0.0) {
                     // water coils not sizing yet
-                    if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingWater || this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, this->m_CoolingCoilName, FirstHVACIteration, this->m_CoolingCoilIndex, QActual, this->m_FanOpMode, 1.0);
-                        EqSizing.DesCoolingLoad = WaterCoils::GetWaterCoilCapacity(
-                            state, Util::makeUPPER(HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num)), this->m_CoolingCoilName, ErrFound);
+                            state, this->m_CoolCoilName, FirstHVACIteration, this->m_CoolCoilNum, QActual, this->m_FanOpMode, 1.0);
+                        EqSizing.DesCoolingLoad = WaterCoils::GetCoilCapacity(state, this->m_CoolCoilNum);
                     }
                 }
                 this->m_MaxNoCoolHeatAirVolFlow *= EqSizing.DesCoolingLoad;
@@ -2165,11 +2095,10 @@ namespace UnitarySystems {
             } else if (this->m_NoCoolHeatSAFMethod == DataSizing::FlowPerHeatingCapacity) {
                 if (EqSizing.DesHeatingLoad <= 0.0) {
                     // water coil not sizing yet
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, this->m_HeatingCoilName, FirstHVACIteration, this->m_HeatingCoilIndex, QActual, this->m_FanOpMode, 1.0);
-                        EqSizing.DesHeatingLoad = WaterCoils::GetWaterCoilCapacity(
-                            state, Util::makeUPPER(HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num)), this->m_HeatingCoilName, ErrFound);
+                            state, this->m_HeatCoilName, FirstHVACIteration, this->m_HeatCoilNum, QActual, this->m_FanOpMode, 1.0);
+                        EqSizing.DesHeatingLoad = WaterCoils::GetCoilCapacity(state, this->m_HeatCoilNum);
                     }
                 }
                 this->m_MaxNoCoolHeatAirVolFlow *= EqSizing.DesHeatingLoad;
@@ -2370,39 +2299,33 @@ namespace UnitarySystems {
                 this->m_MaxNoCoolHeatAirVolFlow = min(this->m_MaxCoolAirVolFlow, this->m_MaxHeatAirVolFlow);
                 this->m_NoLoadAirFlowRateRatio = 1.0;
             }
-            if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed ||
-                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     if (this->m_AirFlowControl == UseCompFlow::On) {
+                        auto const &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum);
                         Real64 airFlowAdjustmentRatio = 1.0;
                         if (!coolingAirFlowIsAutosized) {
-                            airFlowAdjustmentRatio =
-                                this->m_MaxCoolAirVolFlow /
-                                state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex)
-                                    .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).NumOfSpeeds);
+                            airFlowAdjustmentRatio = this->m_MaxCoolAirVolFlow / vsCoil.MSRatedAirVolFlowRate(vsCoil.NumOfSpeeds);
                         }
                         this->m_MaxNoCoolHeatAirVolFlow =
-                            airFlowAdjustmentRatio * state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(1);
+                            airFlowAdjustmentRatio * vsCoil.MSRatedAirVolFlowRate(1);
                     }
                 }
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                     if (this->m_AirFlowControl == UseCompFlow::On) {
+                        auto const &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum);
                         Real64 airFlowAdjustmentRatio = 1.0;
                         if (!heatingAirFlowIsAutosized) {
-                            airFlowAdjustmentRatio =
-                                this->m_MaxHeatAirVolFlow /
-                                state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex)
-                                    .MSRatedAirVolFlowRate(state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).NumOfSpeeds);
+                            airFlowAdjustmentRatio = this->m_MaxHeatAirVolFlow / vsCoil.MSRatedAirVolFlowRate(vsCoil.NumOfSpeeds);
                         }
                         if (this->m_CoolCoilExists) {
                             this->m_MaxNoCoolHeatAirVolFlow =
                                 min(this->m_MaxNoCoolHeatAirVolFlow,
                                     airFlowAdjustmentRatio *
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(1));
+                                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(1));
                         } else {
-                            this->m_MaxNoCoolHeatAirVolFlow =
-                                airFlowAdjustmentRatio *
-                                state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(1);
+                            this->m_MaxNoCoolHeatAirVolFlow = airFlowAdjustmentRatio * vsCoil.MSRatedAirVolFlowRate(1);
                         }
                     }
                 }
@@ -2419,8 +2342,8 @@ namespace UnitarySystems {
         this->m_NoCoolHeatOutAirMassFlow = this->m_NoCoolHeatOutAirVolFlow * state.dataEnvrn->StdRhoAir;
 
         // initialize multi-speed coils
-        if ((this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
-            (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
+        if ((this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) ||
+            (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed)) {
             if (this->m_NumOfSpeedCooling > 0) {
                 if (this->m_CoolVolumeFlowRate.empty()) this->m_CoolVolumeFlowRate.resize(this->m_NumOfSpeedCooling + 1);
                 if (this->m_CoolMassFlowRate.empty()) this->m_CoolMassFlowRate.resize(this->m_NumOfSpeedCooling + 1);
@@ -2438,8 +2361,7 @@ namespace UnitarySystems {
             }
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      blankString,
-                                                      this->m_CoolingCoilIndex,
+                                                      this->m_CoolCoilNum,
                                                       HVAC::FanOp::Invalid, // Invalid instead of off?
                                                       HVAC::CompressorOp::Off,
                                                       0.0,
@@ -2448,16 +2370,15 @@ namespace UnitarySystems {
                                                       0.0,
                                                       0.0,
                                                       0.0); // conduct the sizing operation in the VS WSHP
-            if (this->m_NumOfSpeedCooling != state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).NumOfSpeeds) {
+            if (this->m_NumOfSpeedCooling != state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).NumOfSpeeds) {
                 ShowWarningError(state, format("{}: {} = {}", RoutineName, CompType, CompName));
                 ShowContinueError(state, "Number of cooling speeds does not match coil object.");
                 ShowFatalError(state,
                                format("Cooling coil = {}: {}",
-                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).VarSpeedCoilType,
-                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).Name));
+                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).coilType,
+                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).Name));
             }
-            state.dataSize->DXCoolCap = VariableSpeedCoils::GetCoilCapacityVariableSpeed(
-                state, HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num), this->m_CoolingCoilName, ErrFound);
+            state.dataSize->DXCoolCap = VariableSpeedCoils::GetCoilCapacity(state, this->m_CoolCoilNum);
             EqSizing.DesCoolingLoad = state.dataSize->DXCoolCap;
             if (this->m_DXHeatingCoil) {
                 EqSizing.DesHeatingLoad = state.dataSize->DXCoolCap;
@@ -2467,13 +2388,13 @@ namespace UnitarySystems {
                 // using only for PTUnit to UnitarySystem conversion for the time being, should use this all the time
                 if (this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP || this->m_sysType == SysType::PackagedWSHP) {
                     this->m_MSCoolingSpeedRatio[Iter] =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(Iter) /
-                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(this->m_NumOfSpeedCooling);
+                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(Iter) /
+                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(this->m_NumOfSpeedCooling);
                     this->m_CoolVolumeFlowRate[Iter] = this->m_MaxCoolAirVolFlow * this->m_MSCoolingSpeedRatio[Iter];
                     this->m_CoolMassFlowRate[Iter] = this->MaxCoolAirMassFlow * this->m_MSCoolingSpeedRatio[Iter];
                 } else {
                     this->m_CoolVolumeFlowRate[Iter] =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex).MSRatedAirVolFlowRate(Iter);
+                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum).MSRatedAirVolFlowRate(Iter);
                     this->m_CoolMassFlowRate[Iter] = this->m_CoolVolumeFlowRate[Iter] * state.dataEnvrn->StdRhoAir;
                     // this is divided by the system max air flow, not the cooling coil max air flow, doesn't seem correct
                     this->m_MSCoolingSpeedRatio[Iter] = this->m_CoolVolumeFlowRate[Iter] / this->m_DesignFanVolFlowRate;
@@ -2489,18 +2410,11 @@ namespace UnitarySystems {
                 this->m_NoLoadAirFlowRateRatio = this->m_MaxNoCoolHeatAirVolFlow / this->m_DesignFanVolFlowRate;
             }
 
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
             // mine data from heat exchanger assisted cooling coil
             // Get DX heat exchanger assisted cooling coil index
-            int childCCType_Num = state.dataHVACAssistedCC->HXAssistedCoil(this->m_CoolingCoilIndex).CoolingCoilType_Num;
-            if (childCCType_Num == HVAC::CoilDX_Cooling) {
-                int childCCIndex = state.dataHVACAssistedCC->HXAssistedCoil(this->m_CoolingCoilIndex).CoolingCoilIndex;
-                if (childCCIndex < 0) {
-                    ShowWarningError(state, "Occurs in sizing HeatExchangerAssistedCoolingCoil.");
-                    ShowFatalError(state, "No cooling coil = Coil:Cooling:DX found.");
-                    ErrFound = true;
-                }
-                auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex];
+            if (this->m_childCoolCoilType == HVAC::CoilType::CoolingDX) {
+                auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[m_childCoolCoilNum];
                 this->m_NumOfSpeedCooling = newCoil.performance.normalMode.speeds.size();
                 if (this->m_NumOfSpeedCooling > 0) {
                     if (this->m_CoolVolumeFlowRate.empty()) this->m_CoolVolumeFlowRate.resize(this->m_NumOfSpeedCooling + 1);
@@ -2571,7 +2485,7 @@ namespace UnitarySystems {
                     this->m_NoLoadAirFlowRateRatio = this->m_MaxNoCoolHeatAirVolFlow / this->m_DesignFanVolFlowRate;
                 }
             }
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) {
             if (this->m_NumOfSpeedCooling > 0) {
                 if (this->m_CoolVolumeFlowRate.empty()) this->m_CoolVolumeFlowRate.resize(this->m_NumOfSpeedCooling + 1);
                 if (this->m_CoolMassFlowRate.empty()) this->m_CoolMassFlowRate.resize(this->m_NumOfSpeedCooling + 1);
@@ -2591,7 +2505,8 @@ namespace UnitarySystems {
             }
 
             // mine capacity from Coil:Cooling:DX object
-            auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex];
+            auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum];
+
             // TODO: Determine operating mode based on dehumidification stuff, using normalMode for now
             if (this->m_NumOfSpeedCooling != (int)newCoil.performance.normalMode.speeds.size()) {
                 ShowWarningError(state, format("{}: {} = {}", RoutineName, CompType, CompName));
@@ -2643,7 +2558,8 @@ namespace UnitarySystems {
                 this->m_NoLoadAirFlowRateRatio = this->m_MaxNoCoolHeatAirVolFlow / this->m_DesignFanVolFlowRate;
             }
 
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling || this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                   this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
             if (this->m_NumOfSpeedCooling > 0) {
                 if (this->m_CoolVolumeFlowRate.empty()) this->m_CoolVolumeFlowRate.resize(this->m_NumOfSpeedCooling + 1);
                 if (this->m_CoolMassFlowRate.empty()) this->m_CoolMassFlowRate.resize(this->m_NumOfSpeedCooling + 1);
@@ -2655,13 +2571,12 @@ namespace UnitarySystems {
             state.dataHVACGlobal->MSHPMassFlowRateHigh =
                 EqSizing.CoolingAirVolFlow *
                 state.dataEnvrn->StdRhoAir; // doesn't matter what this value is since only coil size is needed and CompressorOn = 0 here
-            DXCoils::SimDXCoilMultiSpeed(state, blankString, 1.0, 1.0, this->m_CoolingCoilIndex, 0, HVAC::FanOp::Invalid, HVAC::CompressorOp::Off);
+            DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, 1.0, 1.0, 0, HVAC::FanOp::Invalid, HVAC::CompressorOp::Off);
             if (!HardSizeNoDesRun && EqSizing.Capacity) {
                 // do nothing, the vars EqSizing.DesCoolingLoad and DataSizing::DXCoolCap are already set earlier and the values could be max of the
                 // cooling and heating autosized values. Thus resetting them here to user specified value may not be the design size used else where
             } else {
-                state.dataSize->DXCoolCap =
-                    DXCoils::GetCoilCapacityByIndexType(state, this->m_CoolingCoilIndex, this->m_CoolingCoilType_Num, ErrFound);
+                state.dataSize->DXCoolCap = DXCoils::GetCoilCapacity(state, this->m_CoolCoilNum);
                 EqSizing.DesCoolingLoad = state.dataSize->DXCoolCap;
             }
             MSHPIndex = this->m_DesignSpecMSHPIndex;
@@ -2692,7 +2607,7 @@ namespace UnitarySystems {
                 this->MaxNoCoolHeatAirMassFlow = this->m_MaxNoCoolHeatAirVolFlow * state.dataEnvrn->StdRhoAir;
                 this->m_NoLoadAirFlowRateRatio = this->m_MaxNoCoolHeatAirVolFlow / this->m_DesignFanVolFlowRate;
             }
-        } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWater || this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
             if (this->m_NumOfSpeedCooling > 0) {
                 if (this->m_CoolVolumeFlowRate.empty()) this->m_CoolVolumeFlowRate.resize(this->m_NumOfSpeedCooling + 1);
                 if (this->m_CoolMassFlowRate.empty()) this->m_CoolMassFlowRate.resize(this->m_NumOfSpeedCooling + 1);
@@ -2719,8 +2634,9 @@ namespace UnitarySystems {
             }
         }
 
-        if (this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating || this->m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage ||
-            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGas_MultiStage) {
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed ||
+            this->m_heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+            this->m_heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
             if (this->m_NumOfSpeedHeating > 0) {
                 if (this->m_HeatVolumeFlowRate.empty()) this->m_HeatVolumeFlowRate.resize(this->m_NumOfSpeedHeating + 1);
                 if (this->m_HeatMassFlowRate.empty()) this->m_HeatMassFlowRate.resize(this->m_NumOfSpeedHeating + 1);
@@ -2734,16 +2650,16 @@ namespace UnitarySystems {
                 for (Iter = state.dataUnitarySystems->designSpecMSHP[MSHPIndex].numOfSpeedHeating; Iter > 0; --Iter) {
                     if (state.dataUnitarySystems->designSpecMSHP[MSHPIndex].heatingVolFlowRatio[Iter - 1] == DataSizing::AutoSize) {
                         if (this->m_ControlType == UnitarySysCtrlType::Setpoint &&
-                            (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage ||
-                             this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGas_MultiStage)) {
+                            (this->m_heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                             this->m_heatCoilType == HVAC::CoilType::HeatingGasMultiStage)) {
                             state.dataUnitarySystems->designSpecMSHP[MSHPIndex].heatingVolFlowRatio[Iter - 1] = 1.0;
                         } else {
                             state.dataUnitarySystems->designSpecMSHP[MSHPIndex].heatingVolFlowRatio[Iter - 1] =
                                 double(Iter) / double(state.dataUnitarySystems->designSpecMSHP[MSHPIndex].numOfSpeedHeating);
                         }
                     } else {
-                        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage ||
-                            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGas_MultiStage) {
+                        if (this->m_heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                            this->m_heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
                             if (state.dataUnitarySystems->designSpecMSHP[MSHPIndex].heatingVolFlowRatio[Iter - 1] < 1.0 &&
                                 this->m_ControlType == UnitarySysCtrlType::Setpoint) {
                                 ShowWarningError(state, format("{}: {} = {}", RoutineName, CompType, CompName));
@@ -2787,8 +2703,8 @@ namespace UnitarySystems {
                     this->m_NoLoadAirFlowRateRatio = this->m_MaxNoCoolHeatAirVolFlow / this->m_DesignFanVolFlowRate;
                 }
             }
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                   this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+                   this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
             MSHPIndex = this->m_DesignSpecMSHPIndex;
             if (MSHPIndex > -1) {
                 for (Iter = state.dataUnitarySystems->designSpecMSHP[MSHPIndex].numOfSpeedHeating; Iter > 0; --Iter) {
@@ -2800,8 +2716,7 @@ namespace UnitarySystems {
             }
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      blankString,
-                                                      this->m_HeatingCoilIndex,
+                                                      this->m_HeatCoilNum,
                                                       HVAC::FanOp::Invalid,
                                                       HVAC::CompressorOp::Off,
                                                       0.0,
@@ -2811,13 +2726,13 @@ namespace UnitarySystems {
                                                       0.0,
                                                       0.0); // conduct the sizing operation in the VS WSHP
 
-            if (this->m_NumOfSpeedHeating != state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).NumOfSpeeds) {
+            if (this->m_NumOfSpeedHeating != state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).NumOfSpeeds) {
                 ShowWarningError(state, format("{}: {} = {}", RoutineName, CompType, CompName));
                 ShowContinueError(state, "Number of heating speeds does not match coil object.");
                 ShowFatalError(state,
                                format("Heating coil = {}: {}",
-                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).VarSpeedCoilType,
-                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).Name));
+                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).coilType,
+                                      state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).Name));
             }
 
             if (this->m_NumOfSpeedHeating > 0) {
@@ -2831,13 +2746,13 @@ namespace UnitarySystems {
                 if (this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP || this->m_sysType == SysType::PackagedWSHP) {
                     // SpeedRatio is only used in OnOff fan and should represent the ratio of flow to fan max flow
                     this->m_MSHeatingSpeedRatio[Iter] =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(Iter) /
-                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(this->m_NumOfSpeedHeating);
+                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).MSRatedAirVolFlowRate(Iter) /
+                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).MSRatedAirVolFlowRate(this->m_NumOfSpeedHeating);
                     this->m_HeatVolumeFlowRate[Iter] = this->m_MaxHeatAirVolFlow * this->m_MSHeatingSpeedRatio[Iter];
                     this->m_HeatMassFlowRate[Iter] = this->MaxHeatAirMassFlow * this->m_MSHeatingSpeedRatio[Iter];
                 } else {
                     this->m_HeatVolumeFlowRate[Iter] =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex).MSRatedAirVolFlowRate(Iter);
+                        state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum).MSRatedAirVolFlowRate(Iter);
                     this->m_HeatMassFlowRate[Iter] = this->m_HeatVolumeFlowRate[Iter] * state.dataEnvrn->StdRhoAir;
                     if (this->m_DesignFanVolFlowRate > 0.0 && this->m_FanExists) {
                         // this is divided by the system max air flow, not the heating coil max air flow
@@ -2895,14 +2810,10 @@ namespace UnitarySystems {
                 this->m_NoLoadAirFlowRateRatio = this->m_MaxNoCoolHeatAirVolFlow / this->m_DesignFanVolFlowRate;
             }
         }
-        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
             // pass air flow rate to zone water coil
             if (state.dataSize->CurZoneEqNum > 0) {
-                WaterCoils::SetCoilDesFlow(state,
-                                           HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num),
-                                           this->m_HeatingCoilName,
-                                           this->m_MaxHeatAirVolFlow,
-                                           state.dataUnitarySystems->initUnitarySystemsErrorsFound);
+                WaterCoils::SetCoilDesFlow(state, this->m_HeatCoilNum, this->m_MaxHeatAirVolFlow);
             }
 
             if (this->m_NumOfSpeedHeating > 0) {
@@ -2993,49 +2904,42 @@ namespace UnitarySystems {
         if (this->m_CoolCoilExists) {
             SizingMethod = HVAC::CoolingCapacitySizing;
             // water coils must report their size to parent objects (or split out sizing routines for water coils so they can be call from here)
-            if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingWater || this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, this->m_CoolingCoilName, FirstHVACIteration, this->m_CoolingCoilIndex, QActual, this->m_FanOpMode, 1.0);
-                state.dataSize->DataConstantUsedForSizing = WaterCoils::GetWaterCoilCapacity(
-                    state, Util::makeUPPER(HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num)), this->m_CoolingCoilName, ErrFound);
+                    state, this->m_CoolCoilName, FirstHVACIteration, this->m_CoolCoilNum, QActual, this->m_FanOpMode, 1.0);
+                state.dataSize->DataConstantUsedForSizing = WaterCoils::GetCoilCapacity(state, this->m_CoolCoilNum);
                 EqSizing.DesCoolingLoad = state.dataSize->DataConstantUsedForSizing;
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 SizingMethod = HVAC::AutoCalculateSizing;
                 this->m_DesignCoolingCapacity = DataSizing::AutoSize;
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilWater_CoolingHXAssisted) {
-                std::string HXCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(
-                    state, HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num), this->m_CoolingCoilName, ErrFound);
-                int ActualCoolCoilType = HVACHXAssistedCoolingCoil::GetCoilObjectTypeNum(
-                    state, HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num), this->m_CoolingCoilName, ErrFound, true);
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(
-                    state, blankString, true, HVAC::CompressorOp::On, 1.0, this->m_CoolingCoilIndex, HVAC::FanOp::Cycling, false, 1.0, false);
-                state.dataSize->DataConstantUsedForSizing =
-                    WaterCoils::GetWaterCoilCapacity(state, Util::makeUPPER(HVAC::cAllCoilTypes(ActualCoolCoilType)), HXCoilName, ErrFound);
+
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                HXAssistCoil::SimHXAssistedCoolingCoil(
+                    state, this->m_CoolCoilName, true, HVAC::CompressorOp::On, 1.0, this->m_CoolCoilNum, HVAC::FanOp::Cycling, false, 1.0, false);
+                state.dataSize->DataConstantUsedForSizing = WaterCoils::GetCoilCapacity(state, this->m_childCoolCoilNum);
                 EqSizing.DesCoolingLoad = state.dataSize->DataConstantUsedForSizing;
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 SizingMethod = HVAC::AutoCalculateSizing;
                 this->m_DesignCoolingCapacity = DataSizing::AutoSize;
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+                
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                blankString,
-                                                                this->m_CoolingCoilIndex,
+                                                                this->m_CoolCoilNum,
                                                                 this->m_CoolingCoilSensDemand,
                                                                 this->m_CoolingCoilLatentDemand,
                                                                 HVAC::FanOp::Invalid,
                                                                 HVAC::CompressorOp::Off,
                                                                 0.0,
                                                                 FirstHVACIteration);
-                state.dataSize->DataConstantUsedForSizing = WaterToAirHeatPumpSimple::GetCoilCapacity(
-                    state, HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num), this->m_CoolingCoilName, ErrFound);
+                state.dataSize->DataConstantUsedForSizing = WaterToAirHeatPumpSimple::GetCoilCapacity(state, this->m_CoolCoilNum);
                 EqSizing.DesCoolingLoad = state.dataSize->DataConstantUsedForSizing;
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 SizingMethod = HVAC::AutoCalculateSizing;
                 this->m_DesignCoolingCapacity = DataSizing::AutoSize;
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP)
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHP)
                     EqSizing.DesHeatingLoad = state.dataSize->DataConstantUsedForSizing;
                 // airflow sizing with multispeed fan
-                Real64 AirFlowRate = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(
-                    state, HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num), this->m_CoolingCoilName, ErrFound);
+                Real64 AirFlowRate = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(state, this->m_CoolCoilNum);
                 if (this->m_NumOfSpeedCooling > 1) {
                     int FanIndex = this->m_FanIndex;
                     for (int i = 1; i <= this->m_NumOfSpeedCooling; ++i) {
@@ -3054,10 +2958,9 @@ namespace UnitarySystems {
                         this->m_CoolMassFlowRate[i] = this->m_CoolVolumeFlowRate[i] * state.dataEnvrn->StdRhoAir;
                     }
                 }
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHP) {
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHP) {
                 WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                    blankString,
-                                                    this->m_CoolingCoilIndex,
+                                                    this->m_CoolCoilNum,
                                                     this->MaxCoolAirMassFlow,
                                                     this->m_FanOpMode,
                                                     FirstHVACIteration,
@@ -3066,19 +2969,20 @@ namespace UnitarySystems {
                                                     0.0,
                                                     HVAC::CompressorOp::Off,
                                                     0.0);
-                state.dataSize->DataConstantUsedForSizing =
-                    WaterToAirHeatPump::GetCoilCapacity(state, HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num), this->m_CoolingCoilName, ErrFound);
+                
+                state.dataSize->DataConstantUsedForSizing = WaterToAirHeatPump::GetCoilCapacity(state, this->m_CoolCoilNum);
                 EqSizing.DesCoolingLoad = state.dataSize->DataConstantUsedForSizing;
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 SizingMethod = HVAC::AutoCalculateSizing;
-                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                    this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple)
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHP ||
+                    this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple)
                     EqSizing.DesHeatingLoad = state.dataSize->DataConstantUsedForSizing;
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling) {
+
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage) {
                 PackagedThermalStorageCoil::SimTESCoil(
-                    state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, this->m_FanOpMode, this->m_TESOpMode, 0.0);
+                    state, this->m_CoolCoilName, this->m_CoolCoilNum, this->m_FanOpMode, this->m_TESOpMode, 0.0);
                 PackagedThermalStorageCoil::GetTESCoilCoolingCapacity(
-                    state, this->m_CoolingCoilName, state.dataSize->DataConstantUsedForSizing, ErrFound, CompType);
+                    state, this->m_CoolCoilName, state.dataSize->DataConstantUsedForSizing, ErrFound, CompType);
                 EqSizing.DesCoolingLoad = state.dataSize->DataConstantUsedForSizing;
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 SizingMethod = HVAC::AutoCalculateSizing;
@@ -3101,51 +3005,45 @@ namespace UnitarySystems {
             SizingMethod = HVAC::HeatingCapacitySizing;
 
             // water coils must report their size to parent objects (or split out sizing routines for water coils so they can be call from here)
-            if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
+            if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, this->m_HeatingCoilName, FirstHVACIteration, this->m_HeatingCoilIndex, QActual, this->m_FanOpMode, 1.0);
-                state.dataSize->DataConstantUsedForSizing = WaterCoils::GetWaterCoilCapacity(
-                    state, Util::makeUPPER(HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num)), this->m_HeatingCoilName, ErrFound);
+                    state, this->m_HeatCoilName, FirstHVACIteration, this->m_HeatCoilNum, QActual, this->m_FanOpMode, 1.0);
+                state.dataSize->DataConstantUsedForSizing = WaterCoils::GetCoilCapacity(state, this->m_HeatCoilNum);
                 EqSizing.DesHeatingLoad = state.dataSize->DataConstantUsedForSizing;
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 SizingMethod = HVAC::AutoCalculateSizing;
                 this->m_DesignHeatingCapacity = DataSizing::AutoSize;
-            } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple) {
+            } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                blankString,
-                                                                this->m_HeatingCoilIndex,
+                                                                this->m_HeatCoilNum,
                                                                 this->m_HeatingCoilSensDemand,
                                                                 dummy,
                                                                 HVAC::FanOp::Invalid, // Invalid instead of off?
                                                                 HVAC::CompressorOp::Off,
                                                                 0.0,
                                                                 FirstHVACIteration);
-                state.dataSize->DataConstantUsedForSizing = WaterToAirHeatPumpSimple::GetCoilCapacity(
-                    state, HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num), this->m_HeatingCoilName, ErrFound);
+                state.dataSize->DataConstantUsedForSizing = WaterToAirHeatPumpSimple::GetCoilCapacity(state, this->m_HeatCoilNum);
                 EqSizing.DesHeatingLoad = state.dataSize->DataConstantUsedForSizing;
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 SizingMethod = HVAC::AutoCalculateSizing;
                 this->m_DesignHeatingCapacity = DataSizing::AutoSize;
-                if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
                     // adjusted cooling coil capacity
                     WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                    blankString,
-                                                                    this->m_CoolingCoilIndex,
+                                                                    this->m_CoolCoilNum,
                                                                     this->m_CoolingCoilSensDemand,
                                                                     this->m_CoolingCoilLatentDemand,
                                                                     HVAC::FanOp::Invalid, // Invalid instead of off?
                                                                     HVAC::CompressorOp::Off,
                                                                     0.0,
                                                                     FirstHVACIteration);
-                    state.dataSize->DataConstantUsedForSizing = WaterToAirHeatPumpSimple::GetCoilCapacity(
-                        state, HVAC::cAllCoilTypes(this->m_CoolingCoilType_Num), this->m_CoolingCoilName, ErrFound);
+                    state.dataSize->DataConstantUsedForSizing = WaterToAirHeatPumpSimple::GetCoilCapacity(state, this->m_CoolCoilNum);
                     EqSizing.DesCoolingLoad = state.dataSize->DataConstantUsedForSizing;
                 }
                 state.dataSize->DataFractionUsedForSizing = 1.0;
                 this->m_DesignCoolingCapacity = DataSizing::AutoSize;
                 // airflow sizing with multispeed fan
-                Real64 AirFlowRate = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(
-                    state, HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num), this->m_HeatingCoilName, ErrFound);
+                Real64 AirFlowRate = WaterToAirHeatPumpSimple::GetCoilAirFlowRate(state, this->m_HeatCoilNum);
                 if (this->m_NumOfSpeedHeating > 1) {
                     int FanIndex = this->m_FanIndex;
                     for (int i = 1; i <= this->m_NumOfSpeedHeating; ++i) {
@@ -3176,7 +3074,7 @@ namespace UnitarySystems {
             sizerHeatingCapacity.overrideSizingString(SizingString);
             sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
             TempSize = sizerHeatingCapacity.size(state, TempSize, errorsFound);
-            if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) state.dataSize->DXCoolCap = TempSize;
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) state.dataSize->DXCoolCap = TempSize;
             if (state.dataSize->CurSysNum > 0) state.dataAirLoop->AirLoopControlInfo(AirLoopNum).UnitarySysSimulating = true;
             this->m_DesignHeatingCapacity = TempSize;
             state.dataSize->DataConstantUsedForSizing = 0.0;
@@ -3419,12 +3317,11 @@ namespace UnitarySystems {
         std::string const &cCurrentModuleObject = input_data.system_type;
         DataLoopNode::ConnectionObjectType objType = static_cast<DataLoopNode::ConnectionObjectType>(
             getEnumValue(BranchNodeConnections::ConnectionObjectTypeNamesUC, Util::makeUPPER(input_data.system_type)));
-        std::string const &thisObjectName = input_data.name;
-
-        ErrorObjectHeader eoh{routineName, cCurrentModuleObject, thisObjectName};
 
-        this->Name = Util::makeUPPER(thisObjectName);
-        sysNum = getUnitarySystemIndex(state, thisObjectName);
+        this->Name = Util::makeUPPER(input_data.name);
+        
+        ErrorObjectHeader eoh{routineName, cCurrentModuleObject, this->Name};
+        sysNum = getUnitarySystemIndex(state, this->Name);
         this->m_UnitarySysNum = sysNum;
 
         if (ZoneEquipment) {
@@ -3435,7 +3332,7 @@ namespace UnitarySystems {
                                                                   input_data.air_inlet_node_name,
                                                                   errorsFound,
                                                                   objType,
-                                                                  thisObjectName,
+                                                                  this->Name,
                                                                   DataLoopNode::NodeFluidType::Air,
                                                                   DataLoopNode::ConnectionType::Inlet,
                                                                   NodeInputManager::CompFluidStream::Primary,
@@ -3449,7 +3346,7 @@ namespace UnitarySystems {
                                                                    input_data.air_outlet_node_name,
                                                                    errorsFound,
                                                                    objType,
-                                                                   thisObjectName,
+                                                                   this->Name,
                                                                    DataLoopNode::NodeFluidType::Air,
                                                                    DataLoopNode::ConnectionType::Outlet,
                                                                    NodeInputManager::CompFluidStream::Primary,
@@ -3474,18 +3371,19 @@ namespace UnitarySystems {
         }
 
         // these are needed for call from GetOASysNumHeat(Cool)ingCoils
-        this->m_HeatingCoilName = input_data.heating_coil_name;
-        this->m_HeatingCoilTypeName = input_data.heating_coil_object_type;
-        if (!this->m_HeatingCoilTypeName.empty()) {
+        this->m_HeatCoilName = input_data.heating_coil_name;
+        if (!input_data.heating_coil_object_type.empty()) {
             this->m_HeatCoilExists = true;
         }
-        if (this->m_HeatCoilExists && this->m_HeatingCoilType_Num == 0) {
-            if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:DX:VariableSpeed")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingAirToAirVariableSpeed;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:DX:MultiSpeed")) {
-                this->m_HeatingCoilType_Num = HVAC::CoilDX_MultiSpeedHeating;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:Water")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingWater;
+
+        if (this->m_HeatCoilExists) {
+            this->m_heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC,
+                                                                            Util::makeUPPER(input_data.heating_coil_object_type)));
+
+            if (this->m_heatCoilType == HVAC::CoilType::Invalid) {
+                ShowSevereInvalidKey(state, eoh, "heating_coil_object_type", input_data.heating_coil_object_type);
+                errFlag = true;
+            } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
                 if (this->m_DesignSpecMSHPIndex > -1) {
                     this->m_NumOfSpeedHeating = this->m_CompPointerMSHP->numOfSpeedHeating;
                     if (this->m_NumOfSpeedHeating > 1) {
@@ -3493,65 +3391,30 @@ namespace UnitarySystems {
                         this->m_MultiOrVarSpeedHeatCoil = true;
                     }
                 }
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:Steam")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingSteam;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:WaterToAirHeatPump:EquationFit")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingWaterToAirHPSimple;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:WaterToAirHeatPump:ParameterEstimation")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingWaterToAirHP;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingWaterToAirHPVSEquationFit;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:Electric:MultiStage")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingElectric_MultiStage;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:Gas:MultiStage")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_HeatingGas_MultiStage;
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:Fuel") ||
-                       Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:Electric") ||
-                       Util::SameString(this->m_HeatingCoilTypeName, "Coil:Heating:Desuperheater")) {
-                this->m_HeatingCoilType_Num =
-                    HeatingCoils::GetHeatingCoilTypeNum(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, errFlag);
-            } else if (Util::SameString(this->m_HeatingCoilTypeName, "Coil:UserDefined")) {
-                this->m_HeatingCoilType_Num = HVAC::Coil_UserDefined;
-            } else if (this->m_HeatCoilExists) {
-                this->m_HeatingCoilType_Num =
-                    DXCoils::GetCoilTypeNum(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, errFlag, PrintMessage);
-            }
-
-            if (this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage ||
-                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGas_MultiStage) {
+            } else if (this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed ||
+                       this->m_heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                       this->m_heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
                 this->m_MultiSpeedHeatingCoil = true;
-            } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                       this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+                       this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 this->m_VarSpeedHeatingCoil = true;
             }
         }
 
-        this->m_CoolingCoilName = input_data.cooling_coil_name;
+        this->m_CoolCoilName = input_data.cooling_coil_name;
         if (!input_data.cooling_coil_object_type.empty()) { // not required field
             this->m_CoolCoilExists = true;
         }
         // Find the type of coil. do not print message since this may not be the correct coil type.
         errFlag = false;
-        if (this->m_CoolCoilExists && this->m_CoolingCoilType_Num == 0) {
-            if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:DX:VariableSpeed")) {
-                this->m_CoolingCoilType_Num = HVAC::Coil_CoolingAirToAirVariableSpeed;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:DX:MultiSpeed")) {
-                this->m_CoolingCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:Water")) {
-                this->m_IsDXCoil = false;
-                this->m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
-                this->m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
-                if (this->m_DesignSpecMSHPIndex > -1) {
-                    this->m_NumOfSpeedCooling = this->m_CompPointerMSHP->numOfSpeedCooling;
-                    if (this->m_NumOfSpeedCooling > 1) {
-                        this->m_DiscreteSpeedCoolingCoil = true;
-                        this->m_MultiOrVarSpeedCoolCoil = true;
-                    }
-                }
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:Water:DetailedGeometry")) {
+        if (this->m_CoolCoilExists) {
+            this->m_coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Util::makeUPPER(input_data.cooling_coil_object_type)));
+            if (this->m_coolCoilType == HVAC::CoilType::Invalid) {
+                ShowSevereInvalidKey(state, eoh, "cooling_coil_object_type", input_data.cooling_coil_object_type);
+                errFlag = true;
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                       this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
                 this->m_IsDXCoil = false;
-                this->m_CoolingCoilType_Num = HVAC::Coil_CoolingWaterDetailed;
                 if (this->m_DesignSpecMSHPIndex > -1) {
                     this->m_NumOfSpeedCooling = this->m_CompPointerMSHP->numOfSpeedCooling;
                     if (this->m_NumOfSpeedCooling > 1) {
@@ -3559,38 +3422,18 @@ namespace UnitarySystems {
                         this->m_MultiOrVarSpeedCoolCoil = true;
                     }
                 }
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:DX:TwoStageWithHumidityControlMode")) {
-                this->m_CoolingCoilType_Num = HVAC::CoilDX_CoolingTwoStageWHumControl;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "CoilSystem:Cooling:DX:HeatExchangerAssisted")) {
-                this->m_CoolingCoilType_Num = HVACHXAssistedCoolingCoil::GetCoilGroupTypeNum(
-                    state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag, PrintMessage);
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "CoilSystem:Cooling:Water:HeatExchangerAssisted")) {
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) { 
                 this->m_IsDXCoil = false;
-                this->m_CoolingCoilType_Num = HVACHXAssistedCoolingCoil::GetCoilGroupTypeNum(
-                    state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag, PrintMessage);
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:WaterToAirHeatPump:EquationFit")) {
-                this->m_CoolingCoilType_Num = HVAC::Coil_CoolingWaterToAirHPSimple;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:WaterToAirHeatPump:ParameterEstimation")) {
-                this->m_CoolingCoilType_Num = HVAC::Coil_CoolingWaterToAirHP;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit")) {
-                this->m_CoolingCoilType_Num = HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:DX:SingleSpeed")) {
-                this->m_CoolingCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:DX:TwoSpeed")) {
-                this->m_CoolingCoilType_Num = HVAC::CoilDX_CoolingTwoSpeed;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:UserDefined")) {
+            } else if (this->m_coolCoilType == HVAC::CoilType::UserDefined) {
                 this->m_IsDXCoil = false;
-                this->m_CoolingCoilType_Num = HVAC::Coil_UserDefined;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:DX:SingleSpeed:ThermalStorage")) {
-                this->m_CoolingCoilType_Num = HVAC::CoilDX_PackagedThermalStorageCooling;
-            } else if (Util::SameString(input_data.cooling_coil_object_type, "Coil:Cooling:DX")) { // CoilCoolingDX
-                this->m_CoolingCoilType_Num = HVAC::CoilDX_Cooling;
-                this->m_CoolingCoilIndex = CoilCoolingDX::factory(state, this->m_CoolingCoilName);
-                if (this->m_CoolingCoilIndex == -1) {
-                    ShowFatalError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) { 
+                this->m_CoolCoilNum = CoilCoolingDX::factory(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == -1) {
+                    ShowFatalError(state, format("Occurs in {} = {}", cCurrentModuleObject, this->Name));
                 } else {
                     // set variable speed coil flag as necessary
-                    auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex];
+                    auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum];
+
                     this->m_NumOfSpeedCooling = (int)newCoil.performance.normalMode.speeds.size();
                     if (this->m_NumOfSpeedCooling > 1) {
                         if (newCoil.performance.capControlMethod == CoilCoolingDXCurveFitPerformance::CapControlMethod::DISCRETE) {
@@ -3603,10 +3446,10 @@ namespace UnitarySystems {
                 }
             }
 
-            if (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
                 this->m_DiscreteSpeedCoolingCoil = true;
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-                       this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+                       this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                 this->m_ContSpeedCoolingCoil = true;
             }
         }
@@ -3728,7 +3571,7 @@ namespace UnitarySystems {
             this->ControlZoneNum = Util::FindItemInList(input_data.controlling_zone_or_thermostat_location, state.dataHeatBal->Zone);
         } else if (this->m_ControlType == UnitarySysCtrlType::Load || this->m_ControlType == UnitarySysCtrlType::CCMASHRAE) {
             if (this->m_sysType == SysType::Unitary) {
-                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Controlling Zone or Thermostat Location cannot be blank when Control Type = Load or SingleZoneVAV");
                 errorsFound = true;
             }
@@ -3739,7 +3582,7 @@ namespace UnitarySystems {
             // bypass this error for PTUnits
             if (this->ControlZoneNum == 0 &&
                 (this->m_sysType == SysType::Unitary || this->m_sysType == SysType::CoilCoolingDX || this->m_sysType == SysType::CoilCoolingWater)) {
-                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "When Control Type = Load or SingleZoneVAV");
                 ShowContinueError(state,
                                   format(" Controlling Zone or Thermostat Location must be a valid zone name, zone name = {}",
@@ -3765,7 +3608,7 @@ namespace UnitarySystems {
                 AirNodeFound = true;
             }
             if (!AirNodeFound && this->ControlZoneNum > 0) {
-                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Did not find Air Node (Zone with Humidistat).");
                 ShowContinueError(
                     state, format("specified Controlling Zone or Thermostat Location name = {}", input_data.controlling_zone_or_thermostat_location));
@@ -3783,7 +3626,7 @@ namespace UnitarySystems {
 
         // Get AirTerminal mixer data
         SingleDuct::GetATMixer(state,
-                               thisObjectName,
+                               this->Name,
                                this->m_ATMixerName,
                                this->m_ATMixerIndex,
                                this->ATMixerType,
@@ -3819,7 +3662,7 @@ namespace UnitarySystems {
                     // this should be zoneExhaustNode
                     this->m_ZoneInletNode = state.dataZoneEquip->ZoneEquipConfig(ControlledZoneNum).ExhaustNode(ZoneExhNum);
                     this->ControlZoneNum = ControlledZoneNum;
-                    this->setSystemParams(state, TotalFloorAreaOnAirLoop, thisObjectName);
+                    this->setSystemParams(state, TotalFloorAreaOnAirLoop, this->Name);
                     ZoneInletNodeFound = searchZoneInletNodesByEquipmentIndex(state, this->AirOutNode, this->ControlZoneNum);
                 } else { // find if the inlet node is an induced node from zone plenum
                     int ZoneInletNum = 0;
@@ -3832,7 +3675,7 @@ namespace UnitarySystems {
                         if (InducedNodeFound) {
                             this->m_ZoneInletNode = this->AirOutNode;
                             ZoneEquipmentFound = true;
-                            this->setSystemParams(state, TotalFloorAreaOnAirLoop, thisObjectName);
+                            this->setSystemParams(state, TotalFloorAreaOnAirLoop, this->Name);
                         }
                     }
                 }
@@ -3842,7 +3685,7 @@ namespace UnitarySystems {
                     ZoneEquipmentFound = true;
                     this->m_ZoneInletNode = this->AirOutNode;
                     this->ControlZoneNum = ControlledZoneNum;
-                    this->setSystemParams(state, TotalFloorAreaOnAirLoop, thisObjectName);
+                    this->setSystemParams(state, TotalFloorAreaOnAirLoop, this->Name);
                     // The Node was found among the exhaust nodes, now check that a matching inlet node exists
                     ZoneInletNodeFound = searchZoneInletNodesByEquipmentIndex(state, this->AirOutNode, this->ControlZoneNum);
                 } else {
@@ -3856,7 +3699,7 @@ namespace UnitarySystems {
                         if (InducedNodeFound) {
                             this->m_ZoneInletNode = this->AirOutNode;
                             ZoneEquipmentFound = true;
-                            this->setSystemParams(state, TotalFloorAreaOnAirLoop, thisObjectName);
+                            this->setSystemParams(state, TotalFloorAreaOnAirLoop, this->Name);
                         }
                     }
                 }
@@ -3866,7 +3709,7 @@ namespace UnitarySystems {
                     ZoneEquipmentFound = true;
                     this->m_ZoneInletNode = this->ATMixerOutNode;
                     this->ControlZoneNum = ControlledZoneNum;
-                    this->setSystemParams(state, TotalFloorAreaOnAirLoop, thisObjectName);
+                    this->setSystemParams(state, TotalFloorAreaOnAirLoop, this->Name);
                     // The Node was found among the exhaust nodes, now check that a matching inlet node exists
                     ZoneInletNodeFound = searchZoneInletNodesByEquipmentIndex(state, this->ATMixerOutNode, this->ControlZoneNum);
                 } else {
@@ -3880,14 +3723,14 @@ namespace UnitarySystems {
                         if (InducedNodeFound) {
                             this->m_ZoneInletNode = this->ATMixerOutNode;
                             ZoneEquipmentFound = true;
-                            this->setSystemParams(state, TotalFloorAreaOnAirLoop, thisObjectName);
+                            this->setSystemParams(state, TotalFloorAreaOnAirLoop, this->Name);
                         }
                     }
                 }
             }
             if (!ZoneExhaustNodeFound && !InducedNodeFound) {
                 // Exhaust Node was not found
-                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state,
                                   format("Incorrect or misspelled Air Inlet Node Name or Exhaust Node Name or Induced Node Name. = {}",
                                          input_data.air_inlet_node_name));
@@ -3904,7 +3747,7 @@ namespace UnitarySystems {
                 int ZoneInletNum = 0;
                 ZoneInletNodeExists = searchZoneInletNodes(state, this->AirOutNode, InletControlledZoneNum, ZoneInletNum);
                 if (!ZoneInletNodeExists) {
-                    ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, format("Incorrect or misspelled Air Outlet Node Name = {}", input_data.air_outlet_node_name));
                     ShowContinueError(state,
                                       "Node name does not match any controlled zone inlet node name. Check ZoneHVAC:EquipmentConnections "
@@ -3917,7 +3760,7 @@ namespace UnitarySystems {
 
             int compIndex;
             int branchIndex;
-            AirLoopFound = searchTotalComponents(state, this->AirloopEqType, thisObjectName, compIndex, branchIndex, AirLoopNumber);
+            AirLoopFound = searchTotalComponents(state, this->AirloopEqType, this->Name, compIndex, branchIndex, AirLoopNumber);
             if (AirLoopFound && (this->ControlZoneNum > 0)) {
                 //             Find the controlled zone number for the specified thermostat location
                 this->NodeNumOfControlledZone = state.dataZoneEquip->ZoneEquipConfig(this->ControlZoneNum).ZoneNode;
@@ -3939,7 +3782,7 @@ namespace UnitarySystems {
                     AirNodeFound = true;
                 }
                 if (!AirNodeFound && this->ControlZoneNum > 0) {
-                    ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Did not find Air Node (Zone with Thermostat or Thermal Comfort Thermostat).");
                     ShowContinueError(
                         state,
@@ -3968,7 +3811,7 @@ namespace UnitarySystems {
                         AirNodeFound = true;
                     }
                     if (!AirNodeFound && this->ControlZoneNum > 0) {
-                        ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Did not find Air Node (Zone with Thermostat or Thermal Comfort Thermostat).");
                         ShowContinueError(state,
                                           format("specified Controlling Zone or Thermostat Location name = {}",
@@ -3982,7 +3825,7 @@ namespace UnitarySystems {
             if (!AirLoopFound && state.dataAirLoop->NumOASystems > 0) {
                 for (int OASysNum = 1; OASysNum <= state.dataAirLoop->NumOASystems; ++OASysNum) {
                     for (int OACompNum = 1; OACompNum <= state.dataAirLoop->OutsideAirSys(OASysNum).NumComponents; ++OACompNum) {
-                        if (!Util::SameString(state.dataAirLoop->OutsideAirSys(OASysNum).ComponentName(OACompNum), thisObjectName) ||
+                        if (!Util::SameString(state.dataAirLoop->OutsideAirSys(OASysNum).ComponentName(OACompNum), this->Name) ||
                             !Util::SameString(state.dataAirLoop->OutsideAirSys(OASysNum).ComponentType(OACompNum), cCurrentModuleObject))
                             continue;
                         AirLoopNumber = OASysNum;
@@ -3999,11 +3842,11 @@ namespace UnitarySystems {
             if (zoneName.empty() && this->ControlZoneNum > 0) {
                 zoneName = state.dataHeatBal->Zone(this->ControlZoneNum).Name;
             }
-            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
             ShowContinueError(state, "Did not find proper connections for AirLoopHVAC or ZoneHVAC system.");
             ShowContinueError(state, format("specified Controlling Zone or Thermostat Location name = {}", zoneName));
             if (!AirNodeFound && !ZoneEquipmentFound) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Did not find air node (zone with thermostat).");
                 // ShowContinueError(state, format("specified {} = {}", cAlphaFields(iControlZoneAlphaNum), Alphas(iControlZoneAlphaNum)));
                 ShowContinueError(state,
@@ -4037,7 +3880,7 @@ namespace UnitarySystems {
         if (!ZoneEquipment)
             BranchNodeConnections::TestCompSet(state,
                                                cCurrentModuleObject,
-                                               Util::makeUPPER(thisObjectName),
+                                               this->Name,
                                                input_data.air_inlet_node_name,
                                                input_data.air_outlet_node_name,
                                                "Air Nodes");
@@ -4066,7 +3909,7 @@ namespace UnitarySystems {
             this->m_FanExists = true;
             this->m_FanName = loc_m_FanName;
         } else if (!loc_m_FanName.empty() || !loc_fanType.empty()) {
-            ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+            ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
             ShowContinueError(state, format("Invalid Fan Type or Name: Fan Name = {}, Fan Type = {}", loc_m_FanName, loc_fanType));
             errorsFound = true;
         }
@@ -4075,7 +3918,7 @@ namespace UnitarySystems {
         if (this->m_FanExists && this->m_FanCompNotSetYet) {
             BranchNodeConnections::SetUpCompSets(state,
                                                  cCurrentModuleObject,
-                                                 thisObjectName,
+                                                 this->Name,
                                                  loc_fanType,
                                                  loc_m_FanName,
                                                  state.dataLoopNodes->NodeID(FanInletNode),
@@ -4085,7 +3928,7 @@ namespace UnitarySystems {
 
         this->m_FanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Util::makeUPPER(input_data.fan_placement)));
         if (this->m_FanPlace == HVAC::FanPlace::Invalid && this->m_FanExists) {
-            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
             ShowContinueError(state, format("Illegal Fan Placement = {}", input_data.fan_placement));
             errorsFound = true;
         }
@@ -4126,281 +3969,213 @@ namespace UnitarySystems {
         // Get coil data
         this->m_HeatingSizingRatio = input_data.dx_heating_coil_sizing_ratio;
         int HeatingCoilPLFCurveIndex = 0;
-        if (!this->m_HeatingCoilTypeName.empty()) {
+        if (!input_data.heating_coil_object_type.empty()) {
             PrintMessage = false;
         } else {
             this->m_ValidASHRAEHeatCoil = false;
         }
 
-        if (this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed) {
 
             this->m_DXHeatingCoil = true;
 
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            this->m_HeatCoilNum = DXCoils::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
-
-            } else { // mine data from DX heating coil
-
-                // Get DX heating coil index
-                DXCoils::GetDXCoilIndex(state, this->m_HeatingCoilName, this->m_HeatingCoilIndex, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto &thisHeatCoil = state.dataDXCoils->DXCoil(this->m_HeatingCoilIndex);
-                    this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
-                    this->m_DesignHeatingCapacity = thisHeatCoil.RatedTotCap(1);
-                    if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                    this->m_MaxHeatAirVolFlow = thisHeatCoil.RatedAirVolFlowRate(1);
-                    if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                    HeatingCoilInletNode = thisHeatCoil.AirInNode;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutNode;
-                    thisHeatCoil.HeatSizeRatio = this->m_HeatingSizingRatio;
-                }
+                errFlag = false;
+            } else {
+                auto &thisHeatCoil = state.dataDXCoils->DXCoil(this->m_HeatCoilNum);
+                this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
+                this->m_DesignHeatingCapacity = thisHeatCoil.RatedTotCap(1);
+                if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                this->m_MaxHeatAirVolFlow = thisHeatCoil.RatedAirVolFlowRate(1);
+                if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                HeatingCoilInletNode = thisHeatCoil.AirInNode;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutNode;
+                thisHeatCoil.HeatSizeRatio = this->m_HeatingSizingRatio;
             }
 
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                   this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed ||
+                   this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
 
             this->m_DXHeatingCoil = true;
-
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            this->m_HeatCoilNum = VariableSpeedCoils::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
+                errFlag = false;
             } else {
-                this->m_HeatingCoilIndex =
-                    VariableSpeedCoils::GetCoilIndexVariableSpeed(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
-                    errFlag = false;
+                auto const &thisHeatCoil = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatCoilNum);
+                this->m_NumOfSpeedHeating = thisHeatCoil.NumOfSpeeds;
+                this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                this->m_MaxHeatAirVolFlow = thisHeatCoil.RatedAirVolFlowRate;
+                if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) {
+                  this->m_RequestAutoSize = true;
                 } else {
-                    auto const &thisHeatCoil = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_HeatingCoilIndex);
-                    this->m_NumOfSpeedHeating = thisHeatCoil.NumOfSpeeds;
-                    this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                    this->m_MaxHeatAirVolFlow = thisHeatCoil.RatedAirVolFlowRate;
-                    if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) {
-                        this->m_RequestAutoSize = true;
-                    } else {
-                        this->m_MaxHeatAirVolFlow = thisHeatCoil.MSRatedAirVolFlowRate(thisHeatCoil.NumOfSpeeds) /
-                                                    thisHeatCoil.MSRatedAirVolFlowRate(thisHeatCoil.NormSpedLevel) * thisHeatCoil.RatedAirVolFlowRate;
-                    }
-                    HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
-                    this->m_DesignHeatingCapacity = thisHeatCoil.RatedCapHeat;
-                    if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                  this->m_MaxHeatAirVolFlow = thisHeatCoil.MSRatedAirVolFlowRate(thisHeatCoil.NumOfSpeeds) /
+                    thisHeatCoil.MSRatedAirVolFlowRate(thisHeatCoil.NormSpedLevel) * thisHeatCoil.RatedAirVolFlowRate;
                 }
+                HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
+                this->m_DesignHeatingCapacity = thisHeatCoil.RatedCapHeat;
+                if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
             }
-        } else if (this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+            
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
             this->m_DXHeatingCoil = true;
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            this->m_HeatCoilNum = DXCoils::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) { 
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
+                errFlag = false;
             } else {
-                DXCoils::GetDXCoilIndex(state, this->m_HeatingCoilName, this->m_HeatingCoilIndex, errFlag, this->m_HeatingCoilTypeName);
-                if (errFlag) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataDXCoils->DXCoil(this->m_HeatingCoilIndex);
-                    this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
-                    this->m_MaxHeatAirVolFlow = thisHeatCoil.MSRatedAirVolFlowRate(1);
-                    if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                    HeatingCoilInletNode = thisHeatCoil.AirInNode;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutNode;
-                    this->m_DesignHeatingCapacity = thisHeatCoil.MSRatedTotCap(thisHeatCoil.NumOfSpeeds);
-                }
-            }
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage ||
-                   this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGas_MultiStage) {
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                auto const &thisHeatCoil = state.dataDXCoils->DXCoil(this->m_HeatCoilNum);
+                this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
+                this->m_MaxHeatAirVolFlow = thisHeatCoil.MSRatedAirVolFlowRate(1);
+                if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                HeatingCoilInletNode = thisHeatCoil.AirInNode;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutNode;
+                this->m_DesignHeatingCapacity = thisHeatCoil.MSRatedTotCap(thisHeatCoil.NumOfSpeeds);
+            }
+            
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                   this->m_heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
+            this->m_HeatCoilNum = HeatingCoils::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) { 
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
+                errFlag = false;
             } else {
-                HeatingCoils::GetCoilIndex(state, this->m_HeatingCoilName, this->m_HeatingCoilIndex, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataHeatingCoils->HeatingCoil(this->m_HeatingCoilIndex);
-                    HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
-                    this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
-                    this->m_DesignHeatingCapacity = thisHeatCoil.MSNominalCapacity(thisHeatCoil.NumOfStages);
-                    if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                }
-            }
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel || this->m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric ||
-                   this->m_HeatingCoilType_Num == HVAC::Coil_HeatingDesuperheater) {
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                auto const &thisHeatCoil = state.dataHeatingCoils->HeatingCoil(this->m_HeatCoilNum);
+                HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
+                this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
+                this->m_DesignHeatingCapacity = thisHeatCoil.MSNominalCapacity(thisHeatCoil.NumOfStages);
+                if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+            }
+
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                   this->m_heatCoilType == HVAC::CoilType::HeatingElectric ||
+                   this->m_heatCoilType == HVAC::CoilType::HeatingDesuperheater) {
+            this->m_HeatCoilNum = HeatingCoils::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) { 
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
-            } else { // mine data from heating coil
-                HeatingCoils::GetCoilIndex(state, this->m_HeatingCoilName, this->m_HeatingCoilIndex, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataHeatingCoils->HeatingCoil(this->m_HeatingCoilIndex);
-                    this->m_DesignHeatingCapacity = thisHeatCoil.NominalCapacity;
-                    if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                    this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
-                    HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
-                    HeatingCoilPLFCurveIndex = thisHeatCoil.PLFCurveIndex;
-                    // These heating coil types do not have an air flow input field
-                    if (this->m_RequestAutoSize) {
-                        this->m_MaxHeatAirVolFlow = DataSizing::AutoSize;
-                    }
+                errFlag = false;
+            } else {
+                auto const &thisHeatCoil = state.dataHeatingCoils->HeatingCoil(this->m_HeatCoilNum);
+                this->m_DesignHeatingCapacity = thisHeatCoil.NominalCapacity;
+                if (this->m_DesignHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
+                HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
+                HeatingCoilPLFCurveIndex = thisHeatCoil.PLFCurveIndex;
+                // These heating coil types do not have an air flow input field
+                if (this->m_RequestAutoSize) {
+                    this->m_MaxHeatAirVolFlow = DataSizing::AutoSize;
                 }
-            } // IF (IsNotOK) THEN
+            }
 
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
+            this->m_HeatCoilNum = WaterCoils::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) { 
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
-            } else { // mine data from heating coil object
-                this->m_HeatingCoilIndex = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", this->m_HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataWaterCoils->WaterCoil(this->m_HeatingCoilIndex);
-                    this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
-                    this->HeatCoilFluidInletNode = thisHeatCoil.WaterInletNodeNum;
-                    this->MaxHeatCoilFluidFlow = thisHeatCoil.MaxWaterVolFlowRate;
-                    if (this->MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
-                        this->m_RequestAutoSize = true;
-                        this->m_DesignHeatingCapacity = DataSizing::AutoSize;
-                    }
-                    HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
+                errFlag = false;
+            } else {
+                auto const &thisHeatCoil = state.dataWaterCoils->WaterCoil(this->m_HeatCoilNum);
+                this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
+                this->HeatCoilFluidInletNode = thisHeatCoil.WaterInletNodeNum;
+                this->MaxHeatCoilFluidFlow = thisHeatCoil.MaxWaterVolFlowRate;
+                if (this->MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
+                    this->m_RequestAutoSize = true;
+                    this->m_DesignHeatingCapacity = DataSizing::AutoSize;
                 }
+                HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
             }
 
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingSteam) {
+            this->m_HeatCoilNum = SteamCoils::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) { 
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
-            } else { // mine data from heating coil object
-                this->m_HeatingCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", this->m_HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                    ShowContinueError(state, format("Illegal Heating Coil Name = {}", this->m_HeatingCoilName));
-                    errorsFound = true;
+                errFlag = false;
+            } else {
+                auto const &thisHeatCoil = state.dataSteamCoils->SteamCoil(this->m_HeatCoilNum);
+                this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
+                this->HeatCoilFluidInletNode = thisHeatCoil.SteamInletNodeNum;
+                this->MaxHeatCoilFluidFlow = thisHeatCoil.MaxSteamVolFlowRate;
+                if (this->MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
+                    this->m_RequestAutoSize = true;
+                    this->m_DesignHeatingCapacity = DataSizing::AutoSize;
+                }
+                if (this->MaxHeatCoilFluidFlow > 0.0) {
+                    Real64 TempSteamIn = 100.0;
+                    Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, "getUnitarySystemInputData");
+                    this->MaxHeatCoilFluidFlow *= SteamDensity;
                     errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataSteamCoils->SteamCoil(this->m_HeatingCoilIndex);
-                    this->m_heatingCoilAvailSched = thisHeatCoil.availSched;
-                    this->HeatCoilFluidInletNode = thisHeatCoil.SteamInletNodeNum;
-                    this->MaxHeatCoilFluidFlow = thisHeatCoil.MaxSteamVolFlowRate;
-                    if (this->MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
-                        this->m_RequestAutoSize = true;
-                        this->m_DesignHeatingCapacity = DataSizing::AutoSize;
-                    }
-                    if (this->MaxHeatCoilFluidFlow > 0.0) {
-                        Real64 TempSteamIn = 100.0;
-                        Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, "getUnitarySystemInputData");
-                        this->MaxHeatCoilFluidFlow *= SteamDensity;
-                        errFlag = false;
-                    }
-                    HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
-                    if (this->m_RequestAutoSize) {
-                        this->m_MaxHeatAirVolFlow = DataSizing::AutoSize;
-                    }
+                }
+                HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
+                if (this->m_RequestAutoSize) {
+                    this->m_MaxHeatAirVolFlow = DataSizing::AutoSize;
                 }
             }
 
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple) {
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
             this->m_DXHeatingCoil = true;
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            this->m_HeatCoilNum = WaterToAirHeatPumpSimple::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
-            } else { // mine data from heating coil object
-                this->m_HeatingCoilIndex =
-                    WaterToAirHeatPumpSimple::GetCoilIndex(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                    ShowContinueError(state, format("Illegal Heating Coil Name = {}", this->m_HeatingCoilName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(this->m_HeatingCoilIndex);
-                    this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                    this->m_DesignHeatingCapacity = thisHeatCoil.RatedCapHeat;
-                    this->m_MaxHeatAirVolFlow = thisHeatCoil.RatedAirVolFlowRate;
-                    if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                    HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
-                }
+                errFlag = false;
+            } else {
+                auto const &thisHeatCoil = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(this->m_HeatCoilNum);
+                this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                this->m_DesignHeatingCapacity = thisHeatCoil.RatedCapHeat;
+                this->m_MaxHeatAirVolFlow = thisHeatCoil.RatedAirVolFlowRate;
+                if (this->m_MaxHeatAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
             }
 
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP) {
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHP) {
             this->m_DXHeatingCoil = true;
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            this->m_HeatCoilNum = WaterToAirHeatPump::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
-            } else { // mine data from heating coil object
-                this->m_HeatingCoilIndex = WaterToAirHeatPump::GetCoilIndex(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, errFlag);
-                if (errFlag) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                    ShowContinueError(state, format("Illegal Heating Coil Name = {}", this->m_HeatingCoilName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataWaterToAirHeatPump->WatertoAirHP(this->m_HeatingCoilIndex);
-                    this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                    this->m_DesignHeatingCapacity = thisHeatCoil.HeatingCapacity;
-                    HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
-                }
+                errFlag = false;
+            } else {
+                auto const &thisHeatCoil = state.dataWaterToAirHeatPump->WatertoAirHP(this->m_HeatCoilNum);
+                this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                this->m_DesignHeatingCapacity = thisHeatCoil.HeatingCapacity;
+                HeatingCoilInletNode = thisHeatCoil.AirInletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.AirOutletNodeNum;
             }
 
-        } else if (this->m_HeatingCoilType_Num == HVAC::Coil_UserDefined) {
-            ValidateComponent(state, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, isNotOK, cCurrentModuleObject);
-            if (isNotOK) {
-                ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+        } else if (this->m_heatCoilType == HVAC::CoilType::UserDefined) {
+            this->m_HeatCoilNum = UserDefinedComponents::GetCoilIndex(state, this->m_HeatCoilName);
+            if (this->m_HeatCoilNum == 0) {
+                ShowSevereItemNotFound(state, eoh, "heating_coil_name", this->m_HeatCoilName);
                 errorsFound = true;
-            } else { // mine data from Heating coil object
-                UserDefinedComponents::GetUserDefinedCoilIndex(
-                    state, this->m_HeatingCoilName, this->m_HeatingCoilIndex, errFlag, cCurrentModuleObject);
-                if (errFlag) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                    ShowContinueError(state, format("Illegal Heating Coil Name = {}", this->m_HeatingCoilName));
-                    errorsFound = true;
-                    errFlag = false;
-                } else {
-                    auto const &thisHeatCoil = state.dataUserDefinedComponents->UserCoil(this->m_HeatingCoilIndex);
-                    this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                    // **** How to get this info ****
-                    // UnitarySystem( UnitarySysNum ).DesignHeatingCapacity =
-                    //     GetWtoAHPCoilCapacity(CoolingCoilType, this->m_CoolingCoilName,  errFlag );
-                    HeatingCoilInletNode = thisHeatCoil.Air(1).InletNodeNum;
-                    HeatingCoilOutletNode = thisHeatCoil.Air(1).OutletNodeNum;
-                }
+                errFlag = false;
+            } else {
+                auto const &thisHeatCoil = state.dataUserDefinedComponents->UserCoil(this->m_HeatCoilNum);
+                this->m_heatingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                // **** How to get this info ****
+                // UnitarySystem( UnitarySysNum ).DesignHeatingCapacity =
+                //     GetWtoAHPCoilCapacity(CoolingCoilType, this->m_CoolCoilName,  errFlag );
+                HeatingCoilInletNode = thisHeatCoil.Air(1).InletNodeNum;
+                HeatingCoilOutletNode = thisHeatCoil.Air(1).OutletNodeNum;
             }
 
         } else if (this->m_HeatCoilExists) {
-            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-            ShowContinueError(state, format("Illegal Heating Coil Object Type = {}", this->m_HeatingCoilTypeName));
+            ShowSevereInvalidKey(state, eoh, "heating_coil_object_type", input_data.heating_coil_object_type);
             errorsFound = true;
-        } // IF (this->m_HeatingCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
+        } // IF (this->m_heatCoilType == Coil_HeatingGasOrOtherFuel .OR. &, etc.
 
         // coil outlet node set point has priority, IF not exist, then use system outlet node
         if (SetPointManager::NodeHasSPMCtrlVarType(state, this->AirOutNode, HVAC::CtrlVarType::Temp)) this->HeatCtrlNode = this->AirOutNode;
@@ -4411,237 +4186,171 @@ namespace UnitarySystems {
 
         // Add heating coil to component sets array
         if (this->m_HeatCoilExists && this->m_HeatCompNotSetYet) {
-            if (this->m_HeatingCoilType_Num != HVAC::CoilDX_MultiSpeedHeating) {
+            if (this->m_heatCoilType != HVAC::CoilType::HeatingDXMultiSpeed) {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      cCurrentModuleObject,
-                                                     thisObjectName,
-                                                     this->m_HeatingCoilTypeName,
-                                                     this->m_HeatingCoilName,
+                                                     this->Name,
+                                                     HVAC::coilTypeNames[(int)this->m_heatCoilType],
+                                                     this->m_HeatCoilName,
                                                      state.dataLoopNodes->NodeID(HeatingCoilInletNode),
                                                      state.dataLoopNodes->NodeID(HeatingCoilOutletNode));
             } else {
                 BranchNodeConnections::SetUpCompSets(
-                    state, cCurrentModuleObject, thisObjectName, this->m_HeatingCoilTypeName, this->m_HeatingCoilName, "UNDEFINED", "UNDEFINED");
+                    state, cCurrentModuleObject, this->Name, HVAC::coilTypeNames[(int)this->m_heatCoilType], this->m_HeatCoilName, "UNDEFINED", "UNDEFINED");
             }
             this->m_HeatCompNotSetYet = false;
         }
 
         // Get Cooling Coil Information IF available
-        if (!input_data.cooling_coil_object_type.empty() && !this->m_CoolingCoilName.empty()) {
-
-            if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
+        if (!input_data.cooling_coil_object_type.empty() && !this->m_CoolCoilName.empty()) {
 
-                } else { // mine data from DX cooling coil
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed || this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
+                    this->m_NumOfSpeedCooling = 2;
+                    this->m_MultiOrVarSpeedCoolCoil = true;
+                } else {
+                    this->m_NumOfSpeedCooling = 1;
+                    this->m_MultiOrVarSpeedCoolCoil = false;
+                }
 
-                    if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
-                        this->m_NumOfSpeedCooling = 2;
-                        this->m_MultiOrVarSpeedCoolCoil = true;
-                    } else {
-                        this->m_NumOfSpeedCooling = 1;
-                        this->m_MultiOrVarSpeedCoolCoil = false;
+                // Get DX cooling coil index
+                this->m_CoolCoilNum = DXCoils::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
+                    errorsFound = true;
+                } else {
+                    if (state.dataGlobal->DoCoilDirectSolutions && this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+                        DXCoils::DisableLatentDegradation(state, this->m_CoolCoilNum);
                     }
-
-                    // Get DX cooling coil index
-                    DXCoils::GetDXCoilIndex(state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, isNotOK);
-                    if (isNotOK) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
-                    } else {
-                        if (state.dataGlobal->DoCoilDirectSolutions && this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-                            DXCoils::DisableLatentDegradation(state, this->m_CoolingCoilIndex);
-                        }
-                        auto &thisCoolCoil = state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = thisCoolCoil.availSched;
-                        this->m_DesignCoolingCapacity = thisCoolCoil.RatedTotCap(1);
-                        if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate(1);
-                        if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        CoolingCoilInletNode = thisCoolCoil.AirInNode;
-                        CoolingCoilOutletNode = thisCoolCoil.AirOutNode;
-                        this->m_CondenserNodeNum = thisCoolCoil.CondenserInletNodeNum(1);
-
-                        if (this->m_FanExists) {
-                            thisCoolCoil.SupplyFanName = this->m_FanName;
-                            thisCoolCoil.SupplyFanIndex = this->m_FanIndex;
-                            thisCoolCoil.supplyFanType = this->m_FanType;
-                            if (this->m_FanType != HVAC::FanType::Invalid) {
-                                state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
+                    auto &thisCoolCoil = state.dataDXCoils->DXCoil(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = thisCoolCoil.availSched;
+                    this->m_DesignCoolingCapacity = thisCoolCoil.RatedTotCap(1);
+                    if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate(1);
+                    if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    CoolingCoilInletNode = thisCoolCoil.AirInNode;
+                    CoolingCoilOutletNode = thisCoolCoil.AirOutNode;
+                    this->m_CondenserNodeNum = thisCoolCoil.CondenserInletNodeNum(1);
+                    
+                    if (this->m_FanExists) {
+                        thisCoolCoil.SupplyFanName = this->m_FanName;
+                        thisCoolCoil.SupplyFanIndex = this->m_FanIndex;
+                        thisCoolCoil.supplyFanType = this->m_FanType;
+                        if (this->m_FanType != HVAC::FanType::Invalid) {
+                            ReportCoilSelection::setCoilSupplyFanInfo(
                                     state,
                                     thisCoolCoil.Name,
-                                    thisCoolCoil.DXCoilType,
+                                    thisCoolCoil.coilType,
                                     state.dataFans->fans(thisCoolCoil.SupplyFanIndex)->Name,
                                     this->m_FanType,
                                     thisCoolCoil.SupplyFanIndex);
                             }
-                        }
-                        if (this->m_HeatCoilExists) {
-                            if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                                this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                                this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                                this->m_HeatPump = true;
-                            }
-                        }
-
-                        // Push heating coil PLF curve index to DX coil
-                        if (HeatingCoilPLFCurveIndex > 0) {
-                            thisCoolCoil.HeatingCoilPLFCurvePTR = HeatingCoilPLFCurveIndex;
-                        }
-                    }
-                } // IF (IsNotOK) THEN
-
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                    errorsFound = true;
-
-                } else {
-                    //                    // call CoilCoolingDX constructor
-                    this->m_CoolingCoilIndex = CoilCoolingDX::factory(state, this->m_CoolingCoilName);
-                    if (this->m_CoolingCoilIndex == -1) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
-                    } else {
-
-                        // mine data from coil object
-                        // TODO: Need to check for autosize on these I guess
-                        auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex];
-                        this->m_DesignCoolingCapacity = newCoil.performance.normalMode.ratedGrossTotalCap;
-                        this->m_MaxCoolAirVolFlow = newCoil.performance.normalMode.ratedEvapAirFlowRate;
-                        if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        this->m_coolingCoilAvailSched = newCoil.availSched;
-                        CoolingCoilInletNode = newCoil.evapInletNodeIndex;
-                        CoolingCoilOutletNode = newCoil.evapOutletNodeIndex;
-                        this->m_CondenserNodeNum = newCoil.condInletNodeIndex;
-                        this->m_NumOfSpeedCooling = (int)newCoil.performance.normalMode.speeds.size();
-                        this->m_MinOATCompressorCooling = newCoil.performance.minOutdoorDrybulb;
-                        newCoil.supplyFanName = this->m_FanName;
-                        newCoil.supplyFanIndex = this->m_FanIndex;
-                        newCoil.supplyFanType = this->m_FanType;
-                        if (newCoil.SubcoolReheatFlag) {
-                            this->m_Humidistat = true;
-                            if (this->m_NumOfSpeedCooling > 1) {
-                                this->FullOutput.resize(this->m_NumOfSpeedCooling + 1);
-                                this->FullLatOutput.resize(this->m_NumOfSpeedCooling + 1);
-                                this->SpeedSHR.resize(this->m_NumOfSpeedCooling + 1);
-                            }
-                            if (this->m_ControlType == UnitarySysCtrlType::Setpoint) {
-                                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                                ShowContinueError(state,
-                                                  "Setpoint control is not available for SubcoolReheat cooling coil. Load control is forced. "
-                                                  "Simulation continues.");
-                                this->m_ControlType = UnitarySysCtrlType::Load;
-                            }
-                        }
-                        newCoil.setData(this->m_FanIndex, this->m_FanType, this->m_FanName, this->m_SuppCoilPlantLoc.loopNum);
-
-                        // Push heating coil PLF curve index to DX coil
-                        //                    if ( HeatingCoilPLFCurveIndex > 0 ) {
-                        //                        SetDXCoolingCoilData( UnitarySystem( UnitarySysNum ).CoolingCoilIndex, ErrorsFound,
-                        //                        HeatingCoilPLFCurveIndex );
-                        //                    }
-                    }
-
-                    if (state.dataGlobal->DoCoilDirectSolutions && this->m_NumOfSpeedCooling > 1) {
-                        this->FullOutput.resize(this->m_NumOfSpeedCooling + 1);
                     }
-
                     if (this->m_HeatCoilExists) {
-                        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                            this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                            this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                            this->m_HeatPump = true;
-                        }
+                        this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
+                    }
+                    
+                    // Push heating coil PLF curve index to DX coil
+                    if (HeatingCoilPLFCurveIndex > 0) {
+                        thisCoolCoil.HeatingCoilPLFCurvePTR = HeatingCoilPLFCurveIndex;
                     }
                 }
-
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) {
+                this->m_CoolCoilNum = CoilCoolingDX::factory(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == -1) {
+                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, this->Name));
                     errorsFound = true;
-
-                } else { // mine data from DX cooling coil
-
-                    // Get DX cooling coil index
-                    DXCoils::GetDXCoilIndex(state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, isNotOK);
-                    if (isNotOK) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
-                    } else {
-                        auto &thisCoolCoil = state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = thisCoolCoil.availSched;
-                        this->m_DesignCoolingCapacity = thisCoolCoil.RatedTotCap(thisCoolCoil.NumCapacityStages);
-                        if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate(1);
-                        if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        CoolingCoilInletNode = thisCoolCoil.AirInNode;
-                        CoolingCoilOutletNode = thisCoolCoil.AirOutNode;
-                        this->m_CondenserNodeNum = thisCoolCoil.CondenserInletNodeNum(1);
-
-                        // Push heating coil PLF curve index to DX coil
-                        if (HeatingCoilPLFCurveIndex > 0) {
-                            thisCoolCoil.HeatingCoilPLFCurvePTR = HeatingCoilPLFCurveIndex;
+                } else {
+                  
+                    // mine data from coil object
+                    // TODO: Need to check for autosize on these I guess
+                    auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum];
+                    this->m_DesignCoolingCapacity = newCoil.performance.normalMode.ratedGrossTotalCap;
+                    this->m_MaxCoolAirVolFlow = newCoil.performance.normalMode.ratedEvapAirFlowRate;
+                    if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    this->m_coolCoilAvailSched = newCoil.availSched;
+                    CoolingCoilInletNode = newCoil.evapInletNodeIndex;
+                    CoolingCoilOutletNode = newCoil.evapOutletNodeIndex;
+                    this->m_CondenserNodeNum = newCoil.condInletNodeIndex;
+                    this->m_NumOfSpeedCooling = (int)newCoil.performance.normalMode.speeds.size();
+                    this->m_MinOATCompressorCooling = newCoil.performance.minOutdoorDrybulb;
+                    newCoil.supplyFanName = this->m_FanName;
+                    newCoil.supplyFanIndex = this->m_FanIndex;
+                    newCoil.supplyFanType = this->m_FanType;
+                    if (newCoil.SubcoolReheatFlag) {
+                        this->m_Humidistat = true;
+                        if (this->m_NumOfSpeedCooling > 1) {
+                            this->FullOutput.resize(this->m_NumOfSpeedCooling + 1);
+                            this->FullLatOutput.resize(this->m_NumOfSpeedCooling + 1);
+                            this->SpeedSHR.resize(this->m_NumOfSpeedCooling + 1);
                         }
-
-                        if (this->m_HeatCoilExists) {
-                            if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                                this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                                this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                                this->m_HeatPump = true;
-                            }
+                        if (this->m_ControlType == UnitarySysCtrlType::Setpoint) {
+                            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
+                            ShowContinueError(state,
+                                              "Setpoint control is not available for SubcoolReheat cooling coil. Load control is forced. "
+                                              "Simulation continues.");
+                            this->m_ControlType = UnitarySysCtrlType::Load;
                         }
                     }
-                } // IF (IsNotOK) THEN
+                    newCoil.setData(this->m_FanIndex, this->m_FanType, this->m_FanName, this->m_SuppCoilPlantLoc.loopNum);
+                    
+                    // Push heating coil PLF curve index to DX coil
+                    //                    if ( HeatingCoilPLFCurveIndex > 0 ) {
+                    //                        SetDXCoolingCoilData( UnitarySystem( UnitarySysNum ).CoolingCoilIndex, ErrorsFound,
+                    //                        HeatingCoilPLFCurveIndex );
+                    //                    }
+                }
+                
+                if (state.dataGlobal->DoCoilDirectSolutions && this->m_NumOfSpeedCooling > 1) {
+                    this->FullOutput.resize(this->m_NumOfSpeedCooling + 1);
+                }
+                
+                if (this->m_HeatCoilExists) {
+                    this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
+                }
 
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+                    // Get DX cooling coil index
+                this->m_CoolCoilNum = DXCoils::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0){
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
-
-                } else { // mine data from heat exchanger assisted cooling coil
-
-                    // Get DX heat exchanger assisted cooling coil index
-                    HVACHXAssistedCoolingCoil::GetHXDXCoilIndex(state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, isNotOK);
-                    if (isNotOK) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
+                } else {
+                    auto &thisCoolCoil = state.dataDXCoils->DXCoil(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = thisCoolCoil.availSched;
+                    this->m_DesignCoolingCapacity = thisCoolCoil.RatedTotCap(thisCoolCoil.NumCapacityStages);
+                    if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate(1);
+                    if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    CoolingCoilInletNode = thisCoolCoil.AirInNode;
+                    CoolingCoilOutletNode = thisCoolCoil.AirOutNode;
+                    this->m_CondenserNodeNum = thisCoolCoil.CondenserInletNodeNum(1);
+                    
+                    // Push heating coil PLF curve index to DX coil
+                    if (HeatingCoilPLFCurveIndex > 0) {
+                      thisCoolCoil.HeatingCoilPLFCurvePTR = HeatingCoilPLFCurveIndex;
                     }
-
-                    std::string ChildCoolingCoilName =
-                        HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK);
-                    std::string ChildCoolingCoilType =
-                        HVACHXAssistedCoolingCoil::GetHXDXCoilType(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK);
-                    if (isNotOK) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
+                    
+                    if (this->m_HeatCoilExists) {
+                        this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
                     }
+                }
 
-                    if (Util::SameString(ChildCoolingCoilType, "COIL:COOLING:DX")) {
-
-                        int childCCIndex = CoilCoolingDX::factory(state, ChildCoolingCoilName);
-                        if (childCCIndex < 0) {
-                            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                            errorsFound = true;
-                        }
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
+                this->m_CoolCoilNum = HXAssistCoil::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0){
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
+                    errorsFound = true;
+                } else {
+                    this->m_childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, this->m_CoolCoilNum);
+                    this->m_childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, this->m_CoolCoilNum);
+                    this->m_childCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(state, this->m_CoolCoilNum);
 
-                        auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex];
-                        this->m_coolingCoilAvailSched = newCoil.availSched;
+                    if (this->m_childCoolCoilType == HVAC::CoilType::CoolingDX) { 
+                        auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[m_childCoolCoilNum];
+                        this->m_coolCoilAvailSched = newCoil.availSched;
 
                         // thisSys.m_DesignCoolingCapacity = newCoil.performance.normalMode.ratedGrossTotalCap;
                         // Get Coil:Cooling:DX coil air flow rate. Later fields will overwrite this IF input field is present
@@ -4652,434 +4361,252 @@ namespace UnitarySystems {
                         // Get Outdoor condenser node from heat exchanger assisted DX coil object
                         this->m_CondenserNodeNum = newCoil.condInletNodeIndex;
 
-                    } else if (Util::SameString(ChildCoolingCoilType, "COIL:COOLING:DX:SINGLESPEED")) {
-
-                        this->m_coolingCoilAvailSched = DXCoils::GetDXCoilAvailSched(state, ChildCoolingCoilType, ChildCoolingCoilName, errFlag);
-                        if (isNotOK) {
-                            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                            errorsFound = true;
-                        }
+                    } else if (this->m_childCoolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) { 
 
-                        // Get DX coil air flow rate. Later fields will overwrite this IF input field is present
-                        this->m_MaxCoolAirVolFlow = DXCoils::GetDXCoilAirFlow(state, ChildCoolingCoilType, ChildCoolingCoilName, errFlag);
+                        this->m_coolCoilAvailSched = DXCoils::GetCoilAvailSched(state, this->m_childCoolCoilNum);
+                        this->m_MaxCoolAirVolFlow = DXCoils::GetCoilAirFlow(state, this->m_childCoolCoilNum);
                         if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                            errFlag = false;
-                            errorsFound = true;
-                        }
-
-                        // Get Outdoor condenser node from heat exchanger assisted DX coil object
-                        this->m_CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(
-                            state,
-                            "COIL:COOLING:DX:SINGLESPEED",
-                            HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag),
-                            errFlag);
-
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                            errFlag = false;
-                            errorsFound = true;
-                        }
+                        this->m_CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(state, this->m_childCoolCoilNum);
 
-                    } else if (Util::SameString(ChildCoolingCoilType, "COIL:COOLING:DX:VARIABLESPEED")) {
-                        this->m_coolingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                        this->m_MaxCoolAirVolFlow =
-                            VariableSpeedCoils::GetCoilAirFlowRateVariableSpeed(state, ChildCoolingCoilType, ChildCoolingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                            errFlag = false;
-                            errorsFound = true;
-                        }
-                        this->m_CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, ChildCoolingCoilName, errFlag);
-                        if (errFlag) {
-                            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                            errFlag = false;
-                            errorsFound = true;
-                        }
+                    } else if (this->m_childCoolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                        this->m_coolCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                        this->m_MaxCoolAirVolFlow = VariableSpeedCoils::GetCoilAirFlowRate(state, this->m_childCoolCoilNum);
+                        this->m_CondenserNodeNum = VariableSpeedCoils::GetCoilCondenserInletNode(state, this->m_childCoolCoilNum);
                     }
 
                     // Get DX cooling coil capacity
-                    this->m_DesignCoolingCapacity =
-                        HVACHXAssistedCoolingCoil::GetCoilCapacity(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
+                    this->m_DesignCoolingCapacity = HXAssistCoil::GetCoilCapacity(state, this->m_CoolCoilNum);
                     if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errFlag = false;
-                        errorsFound = true;
-                    }
 
                     // Get the Cooling Coil Nodes
-                    CoolingCoilInletNode =
-                        HVACHXAssistedCoolingCoil::GetCoilInletNode(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode =
-                        HVACHXAssistedCoolingCoil::GetCoilOutletNode(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errFlag = false;
-                        errorsFound = true;
-                    }
+                    CoolingCoilInletNode = HXAssistCoil::GetCoilAirInletNode(state, this->m_CoolCoilNum);
+                    CoolingCoilOutletNode = HXAssistCoil::GetCoilAirOutletNode(state, this->m_CoolCoilNum);
 
                     // Push heating coil PLF curve index to DX coil
                     if (HeatingCoilPLFCurveIndex > 0) {
                         // get the actual index to the DX cooling coil object
-                        int DXCoilIndex = HVACHXAssistedCoolingCoil::GetActualDXCoilIndex(
-                            state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errorsFound);
-                        this->m_ActualDXCoilIndexForHXAssisted = DXCoilIndex;
-                        int ActualCoolCoilType = HVACHXAssistedCoolingCoil::GetCoilObjectTypeNum(
-                            state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag, true);
-                        if (ActualCoolCoilType == HVAC::CoilDX_CoolingSingleSpeed) {
-                            DXCoils::SetDXCoolingCoilData(state, DXCoilIndex, errorsFound, HeatingCoilPLFCurveIndex);
+                        this->m_ActualDXCoilIndexForHXAssisted = this->m_childCoolCoilNum;
+                        if (this->m_childCoolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+                            DXCoils::SetCoilHeatingPLFCurve(state, this->m_childCoolCoilNum, HeatingCoilPLFCurveIndex);
                         }
                         // what could we do for VS coil here? odd thing here
                     }
 
                     if (this->m_HeatCoilExists) {
-                        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                            this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                            this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                            this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                            this->m_HeatPump = true;
-                        }
+                        this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
                     }
-
-                } // IF (IsNotOK) THEN
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilWater_CoolingHXAssisted) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                }
+                
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                this->m_CoolCoilNum = HXAssistCoil::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
-
-                } else { // mine data from heat exchanger assisted cooling coil
-
-                    int ActualCoolCoilType = HVACHXAssistedCoolingCoil::GetCoilObjectTypeNum(
-                        state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag, true);
-                    std::string HXCoilName =
-                        HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errFlag = false;
-                        errorsFound = true;
-                    }
-
-                    // Get DX heat exchanger assisted cooling coil index
-                    HVACHXAssistedCoolingCoil::GetHXDXCoilIndex(state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errFlag = false;
-                        errorsFound = true;
-                    }
-
-                    this->m_coolingCoilAvailSched =
-                        WaterCoils::GetWaterCoilAvailSched(state, HVAC::cAllCoilTypes(ActualCoolCoilType), HXCoilName, errFlag);
-                    this->MaxCoolCoilFluidFlow =
-                        WaterCoils::GetCoilMaxWaterFlowRate(state, HVAC::cAllCoilTypes(ActualCoolCoilType), HXCoilName, errFlag);
-                    // Get the Cooling Coil water Inlet Node number
-                    this->CoolCoilFluidInletNode =
-                        WaterCoils::GetCoilWaterInletNode(state, HVAC::cAllCoilTypes(ActualCoolCoilType), HXCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errFlag = false;
-                        errorsFound = true;
-                    }
+                } else {
+                    this->m_childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, this->m_CoolCoilNum);
+                    this->m_childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, this->m_CoolCoilNum);
+                    this->m_childCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(state, this->m_CoolCoilNum);
+                
+                    this->m_coolCoilAvailSched = WaterCoils::GetCoilAvailSched(state, this->m_childCoolCoilNum);
+                    this->MaxCoolCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_childCoolCoilNum);
+                    this->CoolCoilFluidInletNode = WaterCoils::GetCoilWaterInletNode(state, this->m_childCoolCoilNum);
 
                     // Get the Cooling Coil Nodes
-                    CoolingCoilInletNode =
-                        HVACHXAssistedCoolingCoil::GetCoilInletNode(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    CoolingCoilOutletNode =
-                        HVACHXAssistedCoolingCoil::GetCoilOutletNode(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errFlag = false;
-                        errorsFound = true;
-                    }
-
-                    this->m_MaxCoolAirVolFlow =
-                        HVACHXAssistedCoolingCoil::GetHXCoilAirFlowRate(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
+                    CoolingCoilInletNode = HXAssistCoil::GetCoilAirInletNode(state, this->m_CoolCoilNum);
+                    CoolingCoilOutletNode = HXAssistCoil::GetCoilAirOutletNode(state, this->m_CoolCoilNum);
+                    this->m_MaxCoolAirVolFlow = HXAssistCoil::GetCoilMaxAirFlowRate(state, this->m_CoolCoilNum);
                     if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) {
                         this->m_RequestAutoSize = true;
                         this->m_DesignCoolingCapacity = DataSizing::AutoSize;
                     }
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errFlag = false;
-                        errorsFound = true;
-                    }
 
                     this->m_CondenserNodeNum = 0;
 
                     // Push heating coil PLF curve index to DX coil
                     if (HeatingCoilPLFCurveIndex > 0) {
                         // get the actual index to the DX cooling coil object
-                        int DXCoilIndex = HVACHXAssistedCoolingCoil::GetActualDXCoilIndex(
-                            state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errorsFound);
-                        this->m_ActualDXCoilIndexForHXAssisted = DXCoilIndex;
-                        if (ActualCoolCoilType == HVAC::CoilDX_CoolingSingleSpeed) {
-                            DXCoils::SetDXCoolingCoilData(state, DXCoilIndex, errorsFound, HeatingCoilPLFCurveIndex);
+                        this->m_ActualDXCoilIndexForHXAssisted = this->m_childCoolCoilNum;
+                        if (this->m_childCoolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+                            DXCoils::SetCoilHeatingPLFCurve(state, this->m_childCoolCoilNum, HeatingCoilPLFCurveIndex);
                         }
                         // VS coil issue here
                     }
 
                 } // IF (IsNotOK) THEN
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed ||
-                       this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                       this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
+                this->m_CoolCoilNum = VariableSpeedCoils::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "Cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
                 } else {
-                    this->m_CoolingCoilIndex =
-                        VariableSpeedCoils::GetCoilIndexVariableSpeed(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
-                        errFlag = false;
+                    auto &thisCoolCoil = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolCoilNum);
+                    CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
+                    CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
+                    this->m_CondenserNodeNum = thisCoolCoil.CondenserInletNodeNum;
+                    this->m_coolCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                    this->m_NumOfSpeedCooling = thisCoolCoil.NumOfSpeeds;
+                    if (this->m_NumOfSpeedCooling > 1) {
+                        this->m_MultiOrVarSpeedCoolCoil = true;
+                    }
+                    this->m_DesignCoolingCapacity = thisCoolCoil.RatedCapCoolTotal;
+                    if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate;
+                    if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) {
+                        this->m_RequestAutoSize = true;
                     } else {
-                        auto &thisCoolCoil = state.dataVariableSpeedCoils->VarSpeedCoil(this->m_CoolingCoilIndex);
-                        CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
-                        CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
-                        this->m_CondenserNodeNum = thisCoolCoil.CondenserInletNodeNum;
-                        this->m_coolingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                        this->m_NumOfSpeedCooling = thisCoolCoil.NumOfSpeeds;
-                        if (this->m_NumOfSpeedCooling > 1) {
-                            this->m_MultiOrVarSpeedCoolCoil = true;
-                        }
-                        this->m_DesignCoolingCapacity = thisCoolCoil.RatedCapCoolTotal;
-                        if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate;
-                        if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) {
-                            this->m_RequestAutoSize = true;
-                        } else {
-                            this->m_MaxCoolAirVolFlow = thisCoolCoil.MSRatedAirVolFlowRate(thisCoolCoil.NumOfSpeeds) /
-                                                        thisCoolCoil.MSRatedAirVolFlowRate(thisCoolCoil.NormSpedLevel) *
-                                                        thisCoolCoil.RatedAirVolFlowRate;
-                        }
-                        if (this->m_FanExists) { // Set fan info
-                            thisCoolCoil.SupplyFanIndex = this->m_FanIndex;
-                            thisCoolCoil.supplyFanType = this->m_FanType;
-                            thisCoolCoil.SupplyFanName = loc_m_FanName;
-                        }
+                      this->m_MaxCoolAirVolFlow = thisCoolCoil.MSRatedAirVolFlowRate(thisCoolCoil.NumOfSpeeds) /
+                        thisCoolCoil.MSRatedAirVolFlowRate(thisCoolCoil.NormSpedLevel) *
+                        thisCoolCoil.RatedAirVolFlowRate;
+                    }
+                    if (this->m_FanExists) { // Set fan info
+                        thisCoolCoil.SupplyFanIndex = this->m_FanIndex;
+                        thisCoolCoil.supplyFanType = this->m_FanType;
+                        thisCoolCoil.SupplyFanName = loc_m_FanName;
                     }
                 }
 
                 if (this->m_HeatCoilExists) {
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                        this->m_HeatPump = true;
-                    }
+                    this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
                 }
 
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
+                this->m_CoolCoilNum = DXCoils::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
+                    errFlag = false;
                 } else {
-                    DXCoils::GetDXCoilIndex(state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, errFlag, input_data.cooling_coil_object_type);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisCoolCoil = state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = thisCoolCoil.availSched;
-                        CoolingCoilInletNode = thisCoolCoil.AirInNode;
-                        CoolingCoilOutletNode = thisCoolCoil.AirOutNode;
-                        this->m_DesignCoolingCapacity = thisCoolCoil.MSRatedTotCap(thisCoolCoil.NumOfSpeeds);
-                        if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        this->m_MaxCoolAirVolFlow = thisCoolCoil.MSRatedAirVolFlowRate(1);
-                        if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                    }
+                    auto const &thisCoolCoil = state.dataDXCoils->DXCoil(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = thisCoolCoil.availSched;
+                    CoolingCoilInletNode = thisCoolCoil.AirInNode;
+                    CoolingCoilOutletNode = thisCoolCoil.AirOutNode;
+                    this->m_DesignCoolingCapacity = thisCoolCoil.MSRatedTotCap(thisCoolCoil.NumOfSpeeds);
+                    if (this->m_DesignCoolingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    this->m_MaxCoolAirVolFlow = thisCoolCoil.MSRatedAirVolFlowRate(1);
+                    if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
                 }
 
                 if (this->m_HeatCoilExists) {
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                        this->m_HeatPump = true;
-                    }
+                    this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
                 }
 
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
-
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWater || this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
+                this->m_CoolCoilNum = WaterCoils::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
-                } else { // mine data from Cooling coil object
-                    this->m_CoolingCoilIndex =
-                        WaterCoils::GetWaterCoilIndex(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                        ShowContinueError(state, format("Illegal Cooling Coil Name = {}", this->m_CoolingCoilName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisCoolCoil = state.dataWaterCoils->WaterCoil(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = thisCoolCoil.availSched;
-                        if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater) {
-                            this->m_MaxCoolAirVolFlow = thisCoolCoil.DesAirVolFlowRate;
-                        }
-                        this->CoolCoilFluidInletNode = thisCoolCoil.WaterInletNodeNum;
-                        this->MaxCoolCoilFluidFlow = thisCoolCoil.MaxWaterVolFlowRate;
-                        if (this->MaxCoolCoilFluidFlow == DataSizing::AutoSize) {
-                            this->m_RequestAutoSize = true;
-                            this->m_DesignCoolingCapacity = DataSizing::AutoSize; // water coils don't have a capacity field, need other logic?
-                        }
-                        CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
-                        CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
+                    errFlag = false;
+                } else {
+                    auto const &thisCoolCoil = state.dataWaterCoils->WaterCoil(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = thisCoolCoil.availSched;
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingWater) {
+                      this->m_MaxCoolAirVolFlow = thisCoolCoil.DesAirVolFlowRate;
+                    }
+                    this->CoolCoilFluidInletNode = thisCoolCoil.WaterInletNodeNum;
+                    this->MaxCoolCoilFluidFlow = thisCoolCoil.MaxWaterVolFlowRate;
+                    if (this->MaxCoolCoilFluidFlow == DataSizing::AutoSize) {
+                        this->m_RequestAutoSize = true;
+                        this->m_DesignCoolingCapacity = DataSizing::AutoSize; // water coils don't have a capacity field, need other logic?
                     }
+                    CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
+                    CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
                 }
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
+                this->m_CoolCoilNum = WaterToAirHeatPumpSimple::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
-                } else { // mine data from Cooling coil object
-                    this->m_CoolingCoilIndex =
-                        WaterToAirHeatPumpSimple::GetCoilIndex(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    if (errFlag) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                        ShowContinueError(state, format("Illegal Cooling Coil Name = {}", this->m_CoolingCoilName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisCoolCoil = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                        this->m_DesignCoolingCapacity = thisCoolCoil.RatedCapCoolTotal;
-
-                        // this isn't likely to work on getInput calls but is what happened before
-                        int CompanionHeatingCoil = thisCoolCoil.CompanionHeatingCoilNum;
-                        if (CompanionHeatingCoil > 0) {
-                            if (this->m_DesignCoolingCapacity == DataSizing::AutoSize &&
-                                state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(CompanionHeatingCoil).WAHPPlantType ==
-                                    DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
-                                state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(CompanionHeatingCoil).RatedCapHeat == DataSizing::AutoSize &&
-                                state.dataSize->DXCoolCap > 0) {
-                                // Heating coil has not yet been sized, returning the temporary cooling capacity
-                                this->m_DesignCoolingCapacity = state.dataSize->DXCoolCap;
-                            }
-                        }
-
-                        // Get DX coil air flow rate. Later fields will overwrite this IF input field is present
-                        this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate;
-                        if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
-                        CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
-                    }
+                    errFlag = false;
+                } else {
+                    auto const &thisCoolCoil = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                    this->m_DesignCoolingCapacity = thisCoolCoil.RatedCapCoolTotal;
+                    
+                    // this isn't likely to work on getInput calls but is what happened before
+                    int CompanionHeatingCoil = thisCoolCoil.CompanionHeatingCoilNum;
+                    if (CompanionHeatingCoil > 0) {
+                      if (this->m_DesignCoolingCapacity == DataSizing::AutoSize &&
+                          state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(CompanionHeatingCoil).coilPlantType ==
+                          DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
+                          state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(CompanionHeatingCoil).RatedCapHeat == DataSizing::AutoSize &&
+                          state.dataSize->DXCoolCap > 0) {
+                        // Heating coil has not yet been sized, returning the temporary cooling capacity
+                        this->m_DesignCoolingCapacity = state.dataSize->DXCoolCap;
+                      }
+                    }
+                    
+                    // Get DX coil air flow rate. Later fields will overwrite this IF input field is present
+                    this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedAirVolFlowRate;
+                    if (this->m_MaxCoolAirVolFlow == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
+                    CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
                 }
 
                 if (this->m_HeatCoilExists) {
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                        this->m_HeatPump = true;
-                    }
+                    this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
                 }
 
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHP) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHP) {
+                this->m_CoolCoilNum = WaterToAirHeatPump::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
-                } else { // mine data from Cooling coil object
-                    this->m_CoolingCoilIndex =
-                        WaterToAirHeatPump::GetCoilIndex(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
-                    if (this->m_CoolingCoilIndex == 0) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                        ShowContinueError(state, format("Illegal Cooling Coil Name = {}", this->m_CoolingCoilName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisCoolCoil = state.dataWaterToAirHeatPump->WatertoAirHP(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                        this->m_DesignCoolingCapacity = thisCoolCoil.CoolingCapacity;
-                        CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
-                        CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
-                    }
+                    errFlag = false;
+                } else {
+                    auto const &thisCoolCoil = state.dataWaterToAirHeatPump->WatertoAirHP(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                    this->m_DesignCoolingCapacity = thisCoolCoil.CoolingCapacity;
+                    CoolingCoilInletNode = thisCoolCoil.AirInletNodeNum;
+                    CoolingCoilOutletNode = thisCoolCoil.AirOutletNodeNum;
                 }
 
                 if (this->m_HeatCoilExists) {
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                        this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical) {
-                        this->m_HeatPump = true;
-                    }
+                    this->m_HeatPump = HVAC::coilTypeIsHeatPump[(int)this->m_heatCoilType];
                 }
 
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_UserDefined) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::UserDefined) {
+                this->m_CoolCoilNum = UserDefinedComponents::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
-                } else { // mine data from Cooling coil object
-                    UserDefinedComponents::GetUserDefinedCoilIndex(
-                        state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, errFlag, cCurrentModuleObject);
-                    if (errFlag) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                        ShowContinueError(state, format("Illegal Cooling Coil Name = {}", this->m_CoolingCoilName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisCoolCoil = state.dataUserDefinedComponents->UserCoil(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                        // **** How to get this info ****
-                        //  UnitarySystem( UnitarySysNum ).DesignCoolingCapacity =
-                        // GetWtoAHPCoilCapacity(CoolingCoilType, this->m_CoolingCoilName, errFlag );
-                        CoolingCoilInletNode = thisCoolCoil.Air(1).InletNodeNum;
-                        CoolingCoilOutletNode = thisCoolCoil.Air(1).OutletNodeNum;
-                    }
+                    errFlag = false;
+                } else {
+                    auto const &thisCoolCoil = state.dataUserDefinedComponents->UserCoil(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                    // **** How to get this info ****
+                    //  UnitarySystem( UnitarySysNum ).DesignCoolingCapacity =
+                    // GetWtoAHPCoilCapacity(CoolingCoilType, this->m_CoolCoilName, errFlag );
+                    CoolingCoilInletNode = thisCoolCoil.Air(1).InletNodeNum;
+                    CoolingCoilOutletNode = thisCoolCoil.Air(1).OutletNodeNum;
                 }
 
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling) {
-                ValidateComponent(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage) {
+                this->m_CoolCoilNum = PackagedThermalStorageCoil::GetCoilIndex(state, this->m_CoolCoilName);
+                if (this->m_CoolCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "cooling_coil_name", this->m_CoolCoilName);
                     errorsFound = true;
-                } else { // mine data from Cooling coil object
-                    PackagedThermalStorageCoil::GetTESCoilIndex(
-                        state, this->m_CoolingCoilName, this->m_CoolingCoilIndex, errFlag, cCurrentModuleObject);
-                    if (errFlag) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                        ShowContinueError(state, format("Illegal Cooling Coil Name = {}", this->m_CoolingCoilName));
-                        errorsFound = true;
-                        errFlag = false;
+                    errFlag = false;
+                } else {
+                    auto const &thisCoolCoil = state.dataPackagedThermalStorageCoil->TESCoil(this->m_CoolCoilNum);
+                    this->m_coolCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
+                    this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedEvapAirVolFlowRate;
+                    if (thisCoolCoil.CoolingOnlyModeIsAvailable) {
+                        this->m_DesignCoolingCapacity = thisCoolCoil.CoolingOnlyRatedTotCap;
+                    } else if (thisCoolCoil.CoolingAndChargeModeAvailable) {
+                        this->m_DesignCoolingCapacity = thisCoolCoil.CoolingAndChargeRatedTotCap;
+                    } else if (thisCoolCoil.CoolingAndDischargeModeAvailable) {
+                        this->m_DesignCoolingCapacity = thisCoolCoil.CoolingAndDischargeRatedTotCap;
                     } else {
-                        auto const &thisCoolCoil = state.dataPackagedThermalStorageCoil->TESCoil(this->m_CoolingCoilIndex);
-                        this->m_coolingCoilAvailSched = Sched::GetScheduleAlwaysOn(state);
-                        this->m_MaxCoolAirVolFlow = thisCoolCoil.RatedEvapAirVolFlowRate;
-                        if (thisCoolCoil.CoolingOnlyModeIsAvailable) {
-                            this->m_DesignCoolingCapacity = thisCoolCoil.CoolingOnlyRatedTotCap;
-                        } else if (thisCoolCoil.CoolingAndChargeModeAvailable) {
-                            this->m_DesignCoolingCapacity = thisCoolCoil.CoolingAndChargeRatedTotCap;
-                        } else if (thisCoolCoil.CoolingAndDischargeModeAvailable) {
-                            this->m_DesignCoolingCapacity = thisCoolCoil.CoolingAndDischargeRatedTotCap;
-                        } else {
-                            this->m_DesignCoolingCapacity = 0.0;
-                        }
-                        CoolingCoilInletNode = thisCoolCoil.EvapAirInletNodeNum;
-                        CoolingCoilOutletNode = thisCoolCoil.EvapAirOutletNodeNum;
+                        this->m_DesignCoolingCapacity = 0.0;
                     }
+                    CoolingCoilInletNode = thisCoolCoil.EvapAirInletNodeNum;
+                    CoolingCoilOutletNode = thisCoolCoil.EvapAirOutletNodeNum;
                 }
 
-            } else { // IF(.NOT. lAlphaBlanks(16))THEN
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+            } else { 
+                ShowSevereInvalidKey(state, eoh, "cooling_coil_object_type", HVAC::coilTypeNames[(int)this->m_coolCoilType]);
                 // ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(iCoolingCoilTypeAlphaNum), Alphas(iCoolingCoilTypeAlphaNum)));
                 errorsFound = true;
             }
@@ -5089,7 +4616,7 @@ namespace UnitarySystems {
                                                                          input_data.dx_cooling_coil_system_sensor_node_name,
                                                                          errFlag,
                                                                          objType,
-                                                                         thisObjectName,
+                                                                         this->Name,
                                                                          DataLoopNode::NodeFluidType::Air,
                                                                          DataLoopNode::ConnectionType::Sensor,
                                                                          NodeInputManager::CompFluidStream::Primary,
@@ -5107,8 +4634,8 @@ namespace UnitarySystems {
             this->m_ValidASHRAECoolCoil = false;
         }
 
-        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple &&
-            this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple &&
+            this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
             if (!input_data.heat_pump_coil_water_flow_mode.empty()) {
                 this->m_WaterCyclingMode =
                     static_cast<HVAC::WaterFlow>(getEnumValue(HVAC::waterFlowNamesUC, Util::makeUPPER(input_data.heat_pump_coil_water_flow_mode)));
@@ -5116,30 +4643,30 @@ namespace UnitarySystems {
                 this->m_WaterCyclingMode = HVAC::WaterFlow::Cycling;
             }
             WaterToAirHeatPumpSimple::SetSimpleWSHPData(
-                state, this->m_CoolingCoilIndex, errorsFound, this->m_WaterCyclingMode, _, this->m_HeatingCoilIndex);
+                state, this->m_CoolCoilNum, errorsFound, this->m_WaterCyclingMode, _, this->m_HeatCoilNum);
         }
 
-        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit &&
-            this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
-            VariableSpeedCoils::SetVarSpeedCoilData(state, this->m_CoolingCoilIndex, errorsFound, _, this->m_HeatingCoilIndex);
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit &&
+            this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
+            VariableSpeedCoils::SetCoilData(state, this->m_CoolCoilNum, _, this->m_HeatCoilNum);
         }
 
         // Add cooling coil to component sets array
         if (this->m_CoolCoilExists && this->m_CoolCompNotSetYet) {
-            if (this->m_CoolingCoilType_Num != HVAC::CoilDX_MultiSpeedCooling) {
+            if (this->m_coolCoilType != HVAC::CoilType::CoolingDXMultiSpeed) {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      cCurrentModuleObject,
-                                                     thisObjectName,
+                                                     this->Name,
                                                      input_data.cooling_coil_object_type,
-                                                     this->m_CoolingCoilName,
+                                                     this->m_CoolCoilName,
                                                      state.dataLoopNodes->NodeID(CoolingCoilInletNode),
                                                      state.dataLoopNodes->NodeID(CoolingCoilOutletNode));
             } else {
                 BranchNodeConnections::SetUpCompSets(state,
                                                      cCurrentModuleObject,
-                                                     thisObjectName,
+                                                     this->Name,
                                                      input_data.cooling_coil_object_type,
-                                                     this->m_CoolingCoilName,
+                                                     this->m_CoolCoilName,
                                                      "UNDEFINED",
                                                      "UNDEFINED");
             }
@@ -5151,8 +4678,8 @@ namespace UnitarySystems {
         } else {
             if (Util::SameString(input_data.use_doas_dx_cooling_coil, "Yes")) {
                 this->m_ISHundredPercentDOASDXCoil = true;
-                if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                    ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Variable DX Cooling Coil is not supported as 100% DOAS DX coil.");
                     ShowContinueError(state, "Variable DX Cooling Coil resets Use DOAS DX Cooling Coil = No and the simulation continues.");
                     this->m_ISHundredPercentDOASDXCoil = false;
@@ -5167,11 +4694,11 @@ namespace UnitarySystems {
         // considered as as 100% DOAS DX cooling coil
         if (this->m_ISHundredPercentDOASDXCoil) {
             // set the system DX Coil application type to the child DX coil
-            if (!(this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed ||
-                  this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
-                DXCoils::SetDXCoilTypeData(state, this->m_CoolingCoilName);
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
-                state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].setToHundredPercentDOAS();
+            if (!(this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                  this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit)) {
+                DXCoils::SetDXCoilTypeData(state, this->m_CoolCoilName);
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) {
+                state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].setToHundredPercentDOAS();
             }
         }
         // DOAS DX Cooling Coil Leaving Minimum Air Temperature
@@ -5179,14 +4706,14 @@ namespace UnitarySystems {
         if (this->m_ControlType != UnitarySysCtrlType::CCMASHRAE && this->DesignMinOutletTemp == DataSizing::AutoSize) {
             // skip error for PTUnits
             if (this->m_sysType == SysType::Unitary || this->m_sysType == SysType::CoilCoolingDX || this->m_sysType == SysType::CoilCoolingWater) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Invalid entry for Minimum Supply Air Temperature = AutoSize.");
                 ShowContinueError(state, "AutoSizing not allowed when Control Type = Load or Setpoint");
                 errorsFound = true;
             }
         }
         if (this->m_ControlType != UnitarySysCtrlType::CCMASHRAE && this->DesignMinOutletTemp > 7.5) {
-            ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+            ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
             ShowContinueError(state, format("Invalid entry for Minimum Supply Air Temperature = {:.4R}", this->DesignMinOutletTemp));
             ShowContinueError(state, "The minimum supply air temperature will be limited to 7.5C and the simulation continues.");
             this->DesignMinOutletTemp = 7.5;
@@ -5211,7 +4738,7 @@ namespace UnitarySystems {
         }
         if (this->m_DehumidControlType_Num == DehumCtrlType::CoolReheat || this->m_DehumidControlType_Num == DehumCtrlType::Multimode) {
             if (!this->m_RunOnLatentLoad && !this->m_RunOnLatentOnlyWithSensible && this->m_ControlType == UnitarySysCtrlType::Load) {
-                ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Inconsistent moisture control inputs.");
                 ShowContinueError(state, format("Dehumidification Control Type = {}", input_data.dehumidification_control_type));
                 ShowContinueError(state, format("Latent Load Control = {}", input_data.latent_load_control));
@@ -5219,7 +4746,7 @@ namespace UnitarySystems {
             }
         } else {
             if ((this->m_RunOnLatentLoad || this->m_RunOnLatentOnlyWithSensible) && this->m_ControlType == UnitarySysCtrlType::Load) {
-                ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Inconsistent moisture control inputs.");
                 ShowContinueError(state, format("Dehumidification Control Type = {}", input_data.dehumidification_control_type));
                 ShowContinueError(state, format("Latent Load Control = {}", input_data.latent_load_control));
@@ -5230,146 +4757,102 @@ namespace UnitarySystems {
         }
         // Get reheat coil data if humidistat is used
         this->m_SuppHeatCoilName = input_data.supplemental_heating_coil_name;
-        this->m_SuppHeatCoilTypeName = input_data.supplemental_heating_coil_object_type;
-
-        if (Util::SameString(this->m_SuppHeatCoilTypeName, "Coil:Heating:Water")) {
-            this->m_SuppHeatCoilType_Num = HVAC::Coil_HeatingWater;
-        } else if (Util::SameString(this->m_SuppHeatCoilTypeName, "Coil:Heating:Steam")) {
-            this->m_SuppHeatCoilType_Num = HVAC::Coil_HeatingSteam;
-        } else if (Util::SameString(this->m_SuppHeatCoilTypeName, "Coil:Heating:Fuel") ||
-                   Util::SameString(this->m_SuppHeatCoilTypeName, "Coil:Heating:Electric") ||
-                   Util::SameString(this->m_SuppHeatCoilTypeName, "Coil:Heating:Electric:MultiStage") ||
-                   Util::SameString(this->m_SuppHeatCoilTypeName, "Coil:Heating:DesuperHeater")) {
-            this->m_SuppHeatCoilType_Num =
-                HeatingCoils::GetHeatingCoilTypeNum(state, this->m_SuppHeatCoilTypeName, this->m_SuppHeatCoilName, errFlag);
-        } else if (Util::SameString(this->m_SuppHeatCoilTypeName, "Coil:UserDefined")) {
-            this->m_SuppHeatCoilType_Num = HVAC::Coil_UserDefined;
-        }
-
-        if (!this->m_SuppHeatCoilTypeName.empty() && !this->m_SuppHeatCoilName.empty()) {
+        this->m_SuppHeatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC,
+                                                                            Util::makeUPPER(input_data.supplemental_heating_coil_object_type)));
+
+        if (!this->m_SuppHeatCoilName.empty()) {
             errFlag = false;
 
-            if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel || this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingElectric ||
-                this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage ||
-                this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingDesuperheater) {
+            if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectric ||
+                this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                this->m_SuppHeatCoilType == HVAC::CoilType::HeatingDesuperheater) {
 
-                ValidateComponent(state, this->m_SuppHeatCoilTypeName, this->m_SuppHeatCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                this->m_SuppHeatCoilNum = HeatingCoils::GetCoilIndex(state, this->m_SuppHeatCoilName);
+                if (this->m_SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "supplemental_heating_coil_name", this->m_SuppHeatCoilName);
                     errorsFound = true;
-
-                } else { // mine data from reheat coil
-                    this->m_SuppHeatCoilIndex =
-                        HeatingCoils::GetHeatingCoilIndex(state, this->m_SuppHeatCoilTypeName, this->m_SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
-                        errFlag = false;
+                    errFlag = false;
+                } else {
+                    auto const &thisSuppCoil = state.dataHeatingCoils->HeatingCoil(this->m_SuppHeatCoilNum);
+                    if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectricMultiStage) {
+                        this->m_DesignSuppHeatingCapacity = thisSuppCoil.MSNominalCapacity(thisSuppCoil.NumOfStages);
+                        this->m_NumOfSpeedSuppHeating = thisSuppCoil.NumOfStages;
                     } else {
-                        auto const &thisSuppCoil = state.dataHeatingCoils->HeatingCoil(this->m_SuppHeatCoilIndex);
-                        if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage) {
-                            this->m_DesignSuppHeatingCapacity = thisSuppCoil.MSNominalCapacity(thisSuppCoil.NumOfStages);
-                            this->m_NumOfSpeedSuppHeating = thisSuppCoil.NumOfStages;
-                        } else {
-                            this->m_DesignSuppHeatingCapacity = thisSuppCoil.NominalCapacity;
-                        }
-                        if (this->m_DesignSuppHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
-                        SupHeatCoilInletNode = thisSuppCoil.AirInletNodeNum;
-                        SupHeatCoilOutletNode = thisSuppCoil.AirOutletNodeNum;
+                        this->m_DesignSuppHeatingCapacity = thisSuppCoil.NominalCapacity;
                     }
-                } // IF (IsNotOK) THEN
+                    if (this->m_DesignSuppHeatingCapacity == DataSizing::AutoSize) this->m_RequestAutoSize = true;
+                    SupHeatCoilInletNode = thisSuppCoil.AirInletNodeNum;
+                    SupHeatCoilOutletNode = thisSuppCoil.AirOutletNodeNum;
+                }
 
                 this->m_SuppCoilAirInletNode = SupHeatCoilInletNode;
                 this->SuppCoilOutletNodeNum = SupHeatCoilOutletNode;
 
-            } else if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+            } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingWater) {
 
-                ValidateComponent(state, this->m_SuppHeatCoilTypeName, this->m_SuppHeatCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                this->m_SuppHeatCoilNum = WaterCoils::GetCoilIndex(state, this->m_SuppHeatCoilName);
+                if (this->m_SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "supplemental_heating_coil_name", this->m_SuppHeatCoilName);
                     errorsFound = true;
-                } else { // mine data from heating coil object
-                    this->m_SuppHeatCoilIndex = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", this->m_SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisSuppCoil = state.dataWaterCoils->WaterCoil(this->m_SuppHeatCoilIndex);
-                        this->m_SuppCoilFluidInletNode = thisSuppCoil.WaterInletNodeNum;
-                        this->m_MaxSuppCoilFluidFlow = thisSuppCoil.MaxWaterVolFlowRate;
-                        if (this->m_MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
-                            this->m_RequestAutoSize = true;
-                            this->m_DesignSuppHeatingCapacity = DataSizing::AutoSize;
-                        }
-                        SupHeatCoilInletNode = thisSuppCoil.AirInletNodeNum;
-                        this->m_SuppCoilAirInletNode = SupHeatCoilInletNode;
-                        SupHeatCoilOutletNode = thisSuppCoil.AirOutletNodeNum;
-                        this->SuppCoilOutletNodeNum = SupHeatCoilOutletNode;
+                    errFlag = false;
+                } else {
+                    auto const &thisSuppCoil = state.dataWaterCoils->WaterCoil(this->m_SuppHeatCoilNum);
+                    this->m_SuppCoilFluidInletNode = thisSuppCoil.WaterInletNodeNum;
+                    this->m_MaxSuppCoilFluidFlow = thisSuppCoil.MaxWaterVolFlowRate;
+                    if (this->m_MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
+                        this->m_RequestAutoSize = true;
+                        this->m_DesignSuppHeatingCapacity = DataSizing::AutoSize;
                     }
+                    SupHeatCoilInletNode = thisSuppCoil.AirInletNodeNum;
+                    this->m_SuppCoilAirInletNode = SupHeatCoilInletNode;
+                    SupHeatCoilOutletNode = thisSuppCoil.AirOutletNodeNum;
+                    this->SuppCoilOutletNodeNum = SupHeatCoilOutletNode;
                 }
 
-            } else if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+            } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingSteam) {
 
-                ValidateComponent(state, this->m_SuppHeatCoilTypeName, this->m_SuppHeatCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                this->m_SuppHeatCoilNum = SteamCoils::GetCoilIndex(state, this->m_SuppHeatCoilName);
+                if (this->m_SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "supplemental_heating_coil_name", this->m_SuppHeatCoilName);
                     errorsFound = true;
-                } else { // mine data from heating coil object
-                    this->m_SuppHeatCoilIndex = SteamCoils::GetSteamCoilIndex(state, "COIL:HEATING:STEAM", this->m_SuppHeatCoilName, errFlag);
-                    if (errFlag) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                        ShowContinueError(state, format("Illegal Supplemental Heating Coil Name = {}", this->m_SuppHeatCoilName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisSuppCoil = state.dataSteamCoils->SteamCoil(this->m_SuppHeatCoilIndex);
-                        this->m_SuppCoilFluidInletNode = thisSuppCoil.SteamInletNodeNum;
-                        this->m_MaxSuppCoilFluidFlow = thisSuppCoil.MaxSteamVolFlowRate;
-                        if (this->m_MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
-                            this->m_RequestAutoSize = true;
-                            this->m_DesignSuppHeatingCapacity = DataSizing::AutoSize; // not sure if steam coil needs this
-                        }
-                        if (this->m_MaxSuppCoilFluidFlow > 0.0) {
-                            Real64 TempSteamIn = 100.0;
-                            Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, "getUnitarySystemInputData");
-                            this->m_MaxSuppCoilFluidFlow = this->m_MaxSuppCoilFluidFlow * SteamDensity;
-                        }
-                        SupHeatCoilInletNode = thisSuppCoil.AirInletNodeNum;
-                        this->m_SuppCoilAirInletNode = SupHeatCoilInletNode;
-                        SupHeatCoilOutletNode = thisSuppCoil.AirOutletNodeNum;
-                        this->SuppCoilOutletNodeNum = SupHeatCoilOutletNode;
+                    errFlag = false;
+                } else {
+                    auto const &thisSuppCoil = state.dataSteamCoils->SteamCoil(this->m_SuppHeatCoilNum);
+                    this->m_SuppCoilFluidInletNode = thisSuppCoil.SteamInletNodeNum;
+                    this->m_MaxSuppCoilFluidFlow = thisSuppCoil.MaxSteamVolFlowRate;
+                    if (this->m_MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
+                        this->m_RequestAutoSize = true;
+                        this->m_DesignSuppHeatingCapacity = DataSizing::AutoSize; // not sure if steam coil needs this
                     }
+                    if (this->m_MaxSuppCoilFluidFlow > 0.0) {
+                        Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, "getUnitarySystemInputData");
+                        this->m_MaxSuppCoilFluidFlow = this->m_MaxSuppCoilFluidFlow * SteamDensity;
+                    }
+                    SupHeatCoilInletNode = thisSuppCoil.AirInletNodeNum;
+                    this->m_SuppCoilAirInletNode = SupHeatCoilInletNode;
+                    SupHeatCoilOutletNode = thisSuppCoil.AirOutletNodeNum;
+                    this->SuppCoilOutletNodeNum = SupHeatCoilOutletNode;
                 }
 
-            } else if (this->m_SuppHeatCoilType_Num == HVAC::Coil_UserDefined) {
-                ValidateComponent(state, this->m_SuppHeatCoilTypeName, this->m_SuppHeatCoilName, isNotOK, cCurrentModuleObject);
-                if (isNotOK) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            } else if (this->m_SuppHeatCoilType == HVAC::CoilType::UserDefined) {
+                this->m_SuppHeatCoilNum = UserDefinedComponents::GetCoilIndex(state, this->m_SuppHeatCoilName);
+                if (this->m_SuppHeatCoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, "supplemental_heating_coil_name", this->m_SuppHeatCoilName);
                     errorsFound = true;
-                } else { // mine data from Heating coil object
-                    UserDefinedComponents::GetUserDefinedCoilIndex(
-                        state, this->m_SuppHeatCoilName, this->m_SuppHeatCoilIndex, errFlag, cCurrentModuleObject);
-                    if (errFlag) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                        ShowContinueError(state, format("Illegal Supplemental Heating Coil Name = {}", this->m_SuppHeatCoilName));
-                        errorsFound = true;
-                        errFlag = false;
-                    } else {
-                        auto const &thisSuppCoil = state.dataUserDefinedComponents->UserCoil(this->m_SuppHeatCoilIndex);
-                        SupHeatCoilInletNode = thisSuppCoil.Air(1).InletNodeNum;
-                        this->m_SuppCoilAirInletNode = SupHeatCoilInletNode;
-                        SupHeatCoilOutletNode = thisSuppCoil.Air(1).OutletNodeNum;
-                        this->SuppCoilOutletNodeNum = SupHeatCoilOutletNode;
-                    }
+                    errFlag = false;
+                } else {
+                    auto const &thisSuppCoil = state.dataUserDefinedComponents->UserCoil(this->m_SuppHeatCoilNum);
+                    SupHeatCoilInletNode = thisSuppCoil.Air(1).InletNodeNum;
+                    this->m_SuppCoilAirInletNode = SupHeatCoilInletNode;
+                    SupHeatCoilOutletNode = thisSuppCoil.Air(1).OutletNodeNum;
+                    this->SuppCoilOutletNodeNum = SupHeatCoilOutletNode;
                 }
-
+                
             } else { // Illegal reheating coil type
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
-                ShowContinueError(state, format("Illegal Supplemental Heating Coil Type = {}", this->m_SuppHeatCoilTypeName));
+                ShowSevereInvalidKey(state, eoh, "supplemental_heating_coil_object_type", input_data.supplemental_heating_coil_object_type);
                 errorsFound = true;
-            } // IF (this->SuppHeatCoilType_Num == Coil_HeatingGasOrOtherFuel .OR. &, etc.
-
+            } 
         } // IF(.NOT. lAlphaBlanks(iSuppHeatCoilTypeAlphaNum))THEN
 
         if (SetPointManager::NodeHasSPMCtrlVarType(state, this->AirOutNode, HVAC::CtrlVarType::Temp)) this->SuppCtrlNode = this->AirOutNode;
@@ -5379,8 +4862,8 @@ namespace UnitarySystems {
         if (this->m_SuppCoilExists && this->m_SuppCompNotSetYet) {
             BranchNodeConnections::SetUpCompSets(state,
                                                  cCurrentModuleObject,
-                                                 thisObjectName,
-                                                 this->m_SuppHeatCoilTypeName,
+                                                 this->Name,
+                                                 HVAC::coilTypeNames[(int)this->m_SuppHeatCoilType],
                                                  this->m_SuppHeatCoilName,
                                                  state.dataLoopNodes->NodeID(SupHeatCoilInletNode),
                                                  state.dataLoopNodes->NodeID(SupHeatCoilOutletNode));
@@ -5400,8 +4883,8 @@ namespace UnitarySystems {
 
         // set fan info for supplemental heating coils
         if (this->m_SuppCoilExists && this->m_FanExists) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-                state, this->m_SuppHeatCoilName, this->m_SuppHeatCoilTypeName, this->m_FanName, this->m_FanType, this->m_FanIndex);
+            ReportCoilSelection::setCoilSupplyFanInfo(
+                state, this->m_SuppHeatCoilName, this->m_SuppHeatCoilType, this->m_FanName, this->m_FanType, this->m_FanIndex);
         }
 
         // Users may not provide SA flow input fields (below) and leave them blank. Check if other coil is AutoSized first to
@@ -5535,7 +5018,7 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                 } else {
                     if (this->m_MaxCoolAirVolFlow <= HVAC::SmallAirVolFlow && this->m_CoolCoilExists) {
-                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = SupplyAirFlowRate.");
                         ShowContinueError(
                             state,
@@ -5545,7 +5028,7 @@ namespace UnitarySystems {
                 }
 
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = SupplyAirFlowRate.");
                 ShowContinueError(state, "Blank field not allowed for Cooling Supply Air Flow Rate.");
                 errorsFound = true;
@@ -5557,7 +5040,7 @@ namespace UnitarySystems {
                 this->m_MaxCoolAirVolFlow = loc_m_CoolingSAFMethod_SAFlowPerFloorArea;
                 if (this->m_MaxCoolAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxCoolAirVolFlow <= 0.0001 && this->m_CoolCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FlowPerFloorArea.");
                         ShowContinueError(
                             state,
@@ -5569,13 +5052,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FlowPerFloorArea.");
                     ShowContinueError(state, "Illegal Cooling Supply Air Flow Rate Per Floor Area = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FlowPerFloorArea.");
                 ShowContinueError(state, "Blank field not allowed for Cooling Supply Air Flow Rate Per Floor Area.");
                 errorsFound = true;
@@ -5587,7 +5070,7 @@ namespace UnitarySystems {
                 this->m_MaxCoolAirVolFlow = loc_m_CoolingSAFMethod_FracOfAutosizedCoolingSAFlow;
                 if (this->m_MaxCoolAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxCoolAirVolFlow <= HVAC::SmallAirVolFlow && this->m_CoolCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FractionOfAutosizedCoolingValue.");
                         ShowContinueError(state,
                                           format("Suspicious Cooling Fraction of Autosized Cooling Supply Air Flow Rate = {:.7R} [m3/s/m3] "
@@ -5598,13 +5081,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FractionOfAutosizedCoolingValue.");
                     ShowContinueError(state, "Illegal Cooling Fraction of Autosized Cooling Supply Air Flow Rate = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FractionOfAutosizedCoolingValue.");
                 ShowContinueError(state, "Blank field not allowed for Cooling Fraction of Autosized Cooling Supply Air Flow Rate.");
                 errorsFound = true;
@@ -5616,7 +5099,7 @@ namespace UnitarySystems {
                 this->m_MaxCoolAirVolFlow = loc_m_CoolingSAFMethod_FlowPerCoolingCapacity;
                 if (this->m_MaxCoolAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxCoolAirVolFlow <= 0.00001 && this->m_CoolCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FlowPerCoolingCapacity.");
                         ShowContinueError(state,
                                           format("Suspicious Cooling Supply Air Flow Rate Per Unit of Capacity = {:.7R} [m3/s/W] when "
@@ -5627,13 +5110,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FlowPerCoolingCapacity.");
                     ShowContinueError(state, "Illegal Cooling Supply Air Flow Rate Per Unit of Capacity = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Cooling Supply Air Flow Rate Method = FlowPerCoolingCapacity.");
                 ShowContinueError(state, "Blank field not allowed for Cooling Supply Air Flow Rate Per Unit of Capacity.");
                 errorsFound = true;
@@ -5642,7 +5125,7 @@ namespace UnitarySystems {
         } else if (Util::SameString(loc_m_CoolingSAFMethod, "None") || loc_m_CoolingSAFMethod == "") {
             this->m_CoolingSAFMethod = DataSizing::None;
             if (this->m_CoolCoilExists && this->m_MaxCoolAirVolFlow == 0) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 if (this->m_HeatCoilExists) {
                     ShowContinueError(state, "Blank field not allowed for this coil type when heating coil air flow rate is not AutoSized.");
                 } else {
@@ -5661,7 +5144,7 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                 } else {
                     if (this->m_MaxHeatAirVolFlow <= HVAC::SmallAirVolFlow && this->m_HeatCoilExists) {
-                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = SupplyAirFlowRate.");
                         ShowContinueError(
                             state,
@@ -5670,7 +5153,7 @@ namespace UnitarySystems {
                     if (this->m_MaxHeatAirVolFlow < 0.0) errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = SupplyAirFlowRate.");
                 ShowContinueError(state, "Blank field not allowed for Heating Supply Air Flow Rate.");
                 errorsFound = true;
@@ -5681,7 +5164,7 @@ namespace UnitarySystems {
                 this->m_MaxHeatAirVolFlow = loc_m_HeatingSAFMethod_SAFlowPerFloorArea;
                 if (this->m_MaxHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxHeatAirVolFlow <= 0.0001 && this->m_HeatCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FlowPerFloorArea.");
                         ShowContinueError(
                             state,
@@ -5693,13 +5176,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                 } else {
                     // AutoSized input is not allowed
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FlowPerFloorArea.");
                     ShowContinueError(state, "Illegal Heating Supply Air Flow Rate Per Floor Area = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FlowPerFloorArea.");
                 ShowContinueError(state, "Blank field not allowed for Heating Supply Air Flow Rate Per Floor Area.");
                 errorsFound = true;
@@ -5710,7 +5193,7 @@ namespace UnitarySystems {
                 this->m_MaxHeatAirVolFlow = loc_m_HeatingSAFMethod_FracOfAutosizedHeatingSAFlow;
                 if (this->m_MaxHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxHeatAirVolFlow <= HVAC::SmallAirVolFlow && this->m_HeatCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FractionOfAutosizedHeatingValue.");
                         ShowContinueError(state,
                                           format("Suspicious Heating Fraction of Autosized Heating Supply Air Flow Rate = {:.7R} [m3/s/m3] "
@@ -5721,13 +5204,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FractionOfAutosizedHeatingValue");
                     ShowContinueError(state, "Illegal input for Heating Fraction of Autosized Heating Supply Air Flow Rate = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FractionOfAutosizedHeatingValue");
                 ShowContinueError(state, "Blank field not allowed for Heating Fraction of Autosized Heating Supply Air Flow Rate");
                 errorsFound = true;
@@ -5738,7 +5221,7 @@ namespace UnitarySystems {
                 this->m_MaxHeatAirVolFlow = loc_m_HeatingSAFMethod_FlowPerHeatingCapacity;
                 if (this->m_MaxHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxHeatAirVolFlow <= 0.00001 && this->m_HeatCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FlowPerHeatingCapacity.");
                         ShowContinueError(state,
                                           format("Suspicious Heating Supply Air Flow Rate Per Unit of Capacity = {:.7R} [m3/s/W] when "
@@ -5749,13 +5232,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FlowPerHeatingCapacity.");
                     ShowContinueError(state, "Illegal Heating Supply Air Flow Rate Per Unit of Capacity = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method = FlowPerHeatingCapacity");
                 ShowContinueError(state, "Blank field not allowed for Heating Supply Air Flow Rate Per Unit of Capacity");
                 errorsFound = true;
@@ -5763,7 +5246,7 @@ namespace UnitarySystems {
         } else if (Util::SameString(loc_m_HeatingSAFMethod, "None") || loc_m_HeatingSAFMethod == "") {
             this->m_HeatingSAFMethod = DataSizing::None;
             if (this->m_HeatCoilExists && this->m_MaxHeatAirVolFlow == 0) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 if (loc_m_HeatingSAFMethod == "") {
                     ShowContinueError(state, "Input for Heating Supply Air Flow Rate Method is blank.");
                 } else {
@@ -5787,7 +5270,7 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                 } else {
                     if (this->m_MaxNoCoolHeatAirVolFlow < 0.0) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = SupplyAirFlowRate");
                         ShowContinueError(state, format("Illegal No Load Supply Air Flow Rate = {:.7R}", this->m_MaxNoCoolHeatAirVolFlow));
                         errorsFound = true;
@@ -5795,7 +5278,7 @@ namespace UnitarySystems {
                 }
 
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = SupplyAirFlowRate");
                 ShowContinueError(state, "Blank field not allowed for No Load Supply Air Flow Rate");
                 errorsFound = true;
@@ -5806,7 +5289,7 @@ namespace UnitarySystems {
                 this->m_MaxNoCoolHeatAirVolFlow = loc_m_NoCoolHeatSAFMethod_SAFlowPerFloorArea;
                 if (this->m_MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxNoCoolHeatAirVolFlow <= 0.0001) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerFloorArea.");
                         ShowContinueError(
                             state,
@@ -5817,13 +5300,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                 } else {
                     // AutoSized input is not allowed
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerFloorArea.");
                     ShowContinueError(state, "Illegal No Load Supply Air Flow Rate Per Floor Area = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerFloorArea.");
                 ShowContinueError(state, "Blank field not allowed for No Load Supply Air Flow Rate Per Floor Area");
                 errorsFound = true;
@@ -5834,7 +5317,7 @@ namespace UnitarySystems {
                 this->m_MaxNoCoolHeatAirVolFlow = loc_m_NoCoolHeatSAFMethod_FracOfAutosizedCoolingSAFlow;
                 if (this->m_MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxNoCoolHeatAirVolFlow <= HVAC::SmallAirVolFlow) {
-                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FractionOfAutosizedCoolingValue.");
                         ShowContinueError(
                             state,
@@ -5845,14 +5328,14 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FractionOfAutosizedCoolingValue");
                     ShowContinueError(state,
                                       "Illegal input for No Load Supply Air Flow Rate Per Unit of Capacity During Cooling Operation = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FractionOfAutosizedCoolingValue.");
                 ShowContinueError(state, "Blank field not allowed for No Load Supply Air Flow Rate Per Unit of Capacity During Cooling Operation");
                 errorsFound = true;
@@ -5863,7 +5346,7 @@ namespace UnitarySystems {
                 this->m_MaxNoCoolHeatAirVolFlow = loc_m_NoCoolHeatSAFMethod_FracOfAutosizedHeatingSAFlow;
                 if (this->m_MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxNoCoolHeatAirVolFlow <= HVAC::SmallAirVolFlow) {
-                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FractionOfAutosizedHeatingValue.");
                         ShowContinueError(
                             state,
@@ -5874,14 +5357,14 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FractionOfAutosizedHeatingValue");
                     ShowContinueError(state,
                                       "Illegal input for No Load Supply Air Flow Rate Per Unit of Capacity During Heating Operation = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FractionOfAutosizedHeatingValue.");
                 ShowContinueError(state, "Blank field not allowed for No Load Supply Air Flow Rate Per Unit of Capacity During Heating Operation");
                 errorsFound = true;
@@ -5892,7 +5375,7 @@ namespace UnitarySystems {
                 this->m_MaxNoCoolHeatAirVolFlow = loc_m_NoCoolHeatSAFMethod_FlowPerCoolingCapacity;
                 if (this->m_MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxNoCoolHeatAirVolFlow <= 0.00001 && this->m_CoolCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerCoolingCapacity.");
                         ShowContinueError(
                             state,
@@ -5903,13 +5386,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerCoolingCapacity.");
                     ShowContinueError(state, "Illegal No Load Supply Air Flow Rate Per Unit of Capacity During Cooling Operation = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerCoolingCapacity.");
                 ShowContinueError(state, "Blank field not allowed for No Load Supply Air Flow Rate Per Unit of Capacity During Cooling Operation");
                 errorsFound = true;
@@ -5920,7 +5403,7 @@ namespace UnitarySystems {
                 this->m_MaxNoCoolHeatAirVolFlow = loc_m_NoCoolHeatSAFMethod_FlowPerHeatingCapacity;
                 if (this->m_MaxNoCoolHeatAirVolFlow != DataSizing::AutoSize) {
                     if (this->m_MaxNoCoolHeatAirVolFlow <= 0.00001 && this->m_HeatCoilExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerHeatingCapacity.");
                         ShowContinueError(
                             state,
@@ -5931,13 +5414,13 @@ namespace UnitarySystems {
                     this->m_RequestAutoSize = true;
                     // AutoSized input is not allowed
                 } else {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerHeatingCapacity.");
                     ShowContinueError(state, "Illegal No Load Supply Air Flow Rate Per Unit of Capacity During Heating Operation = Autosize");
                     errorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "Input for No Load Supply Air Flow Rate Method = FlowPerHeatingCapacity.");
                 ShowContinueError(state, "Blank field not allowed for No Load Supply Air Flow Rate Per Unit of Capacity During Heating Operation");
                 errorsFound = true;
@@ -5951,12 +5434,12 @@ namespace UnitarySystems {
                 } else if (loc_m_NoCoolHeatSAFMethod_SAFlow == -999.0) { // no load air flow is blank
                     this->m_MaxNoCoolHeatAirVolFlow = DataSizing::AutoSize;
                     this->m_RequestAutoSize = true;
-                    ShowWarningError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                    ShowWarningError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, format("Control Type = {}", input_data.control_type));
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate cannot be blank.");
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate has been set to AutoSize and the simulation continues.");
                 } else if (loc_m_NoCoolHeatSAFMethod_SAFlow == 0.0) { // no load air flow for SZVAV cannot be 0
-                    ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, format("Control Type = {}", input_data.control_type));
                     ShowContinueError(state, "Input for No Load Supply Air Flow Rate cannot be 0.");
                     errorsFound = true;
@@ -5971,7 +5454,7 @@ namespace UnitarySystems {
         if (this->m_FanExists) {
             if (this->m_CoolCoilExists) {
                 if (loc_m_CoolingSAFMethod.empty()) {
-                    ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "Method used to determine the cooling supply air flow rate is not specified when cooling coil is present.");
                     // check if all cooling flow calc method fields are blank
@@ -5988,12 +5471,12 @@ namespace UnitarySystems {
                     }
                 }
                 // set fan info for cooling coils
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-                    state, this->m_CoolingCoilName, input_data.cooling_coil_object_type, this->m_FanName, this->m_FanType, this->m_FanIndex);
+                ReportCoilSelection::setCoilSupplyFanInfo(
+                    state, this->m_CoolCoilName, this->m_coolCoilType, this->m_FanName, this->m_FanType, this->m_FanIndex);
             }
             if (this->m_HeatCoilExists) {
                 if (loc_m_HeatingSAFMethod.empty()) {
-                    ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "Method used to determine the heating supply air flow rate is not specified when heating coil is present.");
                     // check if all heating flow calc method fields are blank
@@ -6010,8 +5493,8 @@ namespace UnitarySystems {
                     }
                 }
                 // set fan info for heating coils
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
-                    state, this->m_HeatingCoilName, this->m_HeatingCoilTypeName, this->m_FanName, this->m_FanType, this->m_FanIndex);
+                ReportCoilSelection::setCoilSupplyFanInfo(
+                    state, this->m_HeatCoilName, this->m_heatCoilType, this->m_FanName, this->m_FanType, this->m_FanIndex);
             }
         }
 
@@ -6032,26 +5515,26 @@ namespace UnitarySystems {
             }
         }
 
-        if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && this->m_DehumidControlType_Num == DehumCtrlType::Multimode) {
-            int numCoolingCoilModes = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getNumModes();
+        if (this->m_coolCoilType == HVAC::CoilType::CoolingDX && this->m_DehumidControlType_Num == DehumCtrlType::Multimode) {
+            int numCoolingCoilModes = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].getNumModes();
             if (numCoolingCoilModes == 1) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, format("Illegal Dehumidification Control Type = {}", input_data.dehumidification_control_type));
                 ShowContinueError(state, "Multimode control must be used with a Heat Exchanger Assisted or Multimode Cooling Coil.");
                 ShowContinueError(
-                    state,
-                    format("Cooling coil named: {} has only one mode", state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].name));
+                    state, format("Cooling coil named: {} has only one mode", state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].name));
                 ShowFatalError(state, "Multimode cooling coil error causes program termination");
             }
-        } else if (this->m_CoolingCoilType_Num != HVAC::CoilDX_CoolingHXAssisted &&
-                   this->m_CoolingCoilType_Num != HVAC::CoilDX_CoolingTwoStageWHumControl &&
-                   this->m_CoolingCoilType_Num != HVAC::CoilWater_CoolingHXAssisted && this->m_DehumidControlType_Num == DehumCtrlType::Multimode) {
-            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+            
+        } else if (this->m_coolCoilType != HVAC::CoilType::CoolingDXHXAssisted &&
+                   this->m_coolCoilType != HVAC::CoilType::CoolingDXTwoStageWHumControl &&
+                   this->m_coolCoilType != HVAC::CoilType::CoolingWaterHXAssisted && this->m_DehumidControlType_Num == DehumCtrlType::Multimode) {
+            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
             ShowContinueError(state, format("Illegal Dehumidification Control Type = {}", input_data.dehumidification_control_type));
             ShowContinueError(state, "Multimode control must be used with a Heat Exchanger Assisted or Multimode Cooling Coil.");
-            if (this->m_SuppHeatCoilName == "" && this->m_SuppHeatCoilTypeName == "") {
+            if (this->m_SuppHeatCoilName == "") {
             } else {
-                if (this->m_CoolingCoilType_Num == HVAC::Coil_UserDefined) {
+                if (this->m_coolCoilType == HVAC::CoilType::UserDefined) {
                     ShowContinueError(state, "Dehumidification control type is assumed to be None and the simulation continues.");
                     this->m_DehumidControlType_Num = DehumCtrlType::None;
                 } else {
@@ -6078,7 +5561,7 @@ namespace UnitarySystems {
                 this->m_CoolingCoilUpstream = false;
             }
             if (ZoneEquipmentFound) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "ZoneHVAC equipment must contain a fan object.");
                 ShowContinueError(state, format("specified Supply Fan Object Type = {}", loc_fanType));
                 ShowContinueError(state, format("specified Supply Fan Name = {}", loc_m_FanName));
@@ -6094,7 +5577,7 @@ namespace UnitarySystems {
                 tmpAirInletNode = this->m_OAMixerNodes[3]; // mixed air node
             }
             if (FanInletNode != tmpAirInletNode) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 if (this->OAMixerExists) {
                     ShowContinueError(state,
                                       "When a blow through fan is specified, the fan inlet node name must be the same as the outdoor "
@@ -6112,7 +5595,7 @@ namespace UnitarySystems {
             }
             if (this->m_CoolingCoilUpstream) {
                 if (FanOutletNode != CoolingCoilInletNode && this->m_CoolCoilExists && this->m_FanExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "When a blow through fan is specified, the fan outlet node name must be the same as the cooling coil "
                                       "inlet node name.");
@@ -6121,7 +5604,7 @@ namespace UnitarySystems {
                     errorsFound = true;
                 }
                 if (CoolingCoilOutletNode != HeatingCoilInletNode && this->m_CoolCoilExists && this->m_HeatCoilExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
                     ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
                     ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
@@ -6129,7 +5612,7 @@ namespace UnitarySystems {
                 }
                 if (this->m_SuppCoilExists) {
                     if (SupHeatCoilOutletNode != this->AirOutNode) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "The reheat coil outlet node name must be the same as the unitary system outlet node name.");
                         ShowContinueError(state,
                                           format("...Reheat coil outlet node name   = {}" + state.dataLoopNodes->NodeID(SupHeatCoilOutletNode)));
@@ -6139,7 +5622,7 @@ namespace UnitarySystems {
                 } else { // IF((this->m_Humidistat ...
                     // Heating coil outlet node name must be the same as the Unitary system outlet node name
                     if (this->m_HeatCoilExists && HeatingCoilOutletNode != this->AirOutNode) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state,
                                           "When a blow through fan is specified, the heating coil outlet node name must be the same as the "
                                           "unitary system outlet node name.");
@@ -6151,7 +5634,7 @@ namespace UnitarySystems {
                 }
             } else { // IF(this->CoolingCoilUpstream)THEN
                 if (FanOutletNode != HeatingCoilInletNode && this->m_FanExists && this->m_HeatCoilExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "When a blow through fan is specified, the fan outlet node name must be the same as the heating coil "
                                       "inlet node name.");
@@ -6160,14 +5643,14 @@ namespace UnitarySystems {
                     errorsFound = true;
                 }
                 if (HeatingCoilOutletNode != CoolingCoilInletNode && this->m_CoolCoilExists && this->m_HeatCoilExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "The heating coil outlet node name must be the same as the cooling coil inlet node name.");
                     ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
                     ShowContinueError(state, format("...Cooling coil inlet node name  = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
                     errorsFound = true;
                 }
                 if (CoolingCoilOutletNode != this->AirOutNode && this->m_CoolCoilExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "When a blow through fan is specified, the cooling coil outlet node name must be the same as the unitary "
                                       "system outlet node name.");
@@ -6186,7 +5669,7 @@ namespace UnitarySystems {
             if (this->m_CoolingCoilUpstream) {
                 if (CoolingCoilInletNode != tmpAirInletNode && CoolingCoilInletNode != 0 && this->m_FanExists) {
                     if (this->OAMixerExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state,
                                           "When a draw through fan is specified, the cooling coil inlet node name must be the same as the outdoor "
                                           "air mixer mixed air node name.");
@@ -6194,7 +5677,7 @@ namespace UnitarySystems {
                                           format("...Cooling coil inlet node name      = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
                         ShowContinueError(state, format("...UnitarySystem mixed air node name = {}", state.dataLoopNodes->NodeID(tmpAirInletNode)));
                     } else {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state,
                                           "When a draw through fan is specified, the cooling coil inlet node name must be the same as the unitary "
                                           "system inlet node name.");
@@ -6204,14 +5687,14 @@ namespace UnitarySystems {
                     errorsFound = true;
                 }
                 if (CoolingCoilOutletNode != HeatingCoilInletNode && this->m_CoolCoilExists && this->m_HeatCoilExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "The cooling coil outlet node name must be the same as the heating coil inlet node name.");
                     ShowContinueError(state, format("...Cooling coil outlet node name = {}", state.dataLoopNodes->NodeID(CoolingCoilOutletNode)));
                     ShowContinueError(state, format("...Heating coil inlet node name  = {}", state.dataLoopNodes->NodeID(HeatingCoilInletNode)));
                     errorsFound = true;
                 }
                 if (HeatingCoilOutletNode != FanInletNode && this->m_HeatCoilExists && this->m_FanExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "When a draw through fan is specified, the heating coil outlet node name must be the same as the fan "
                                       "inlet node name.");
@@ -6221,7 +5704,7 @@ namespace UnitarySystems {
                 }
                 if (this->m_SuppCoilExists) {
                     if (FanOutletNode != SupHeatCoilInletNode && this->m_FanExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state,
                                           "When a draw through fan is specified, the fan outlet node name must be the same as the reheat coil "
                                           "inlet node name.");
@@ -6230,7 +5713,7 @@ namespace UnitarySystems {
                         errorsFound = true;
                     }
                     if (SupHeatCoilOutletNode != this->AirOutNode) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state, "The reheat coil outlet node name must be the same as the unitary system outlet node name.");
                         ShowContinueError(state,
                                           format("...Reheat coil outlet node name   = {}", state.dataLoopNodes->NodeID(SupHeatCoilOutletNode)));
@@ -6239,7 +5722,7 @@ namespace UnitarySystems {
                     }
                 } else {
                     if (FanOutletNode != this->AirOutNode && this->m_FanExists) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state,
                                           "When a draw through fan is specified, the fan outlet node name must be the same as the unitary system "
                                           "outlet node name.");
@@ -6250,7 +5733,7 @@ namespace UnitarySystems {
                 }
             } else { // IF(this->CoolingCoilUpstream)THEN
                 if (HeatingCoilInletNode != tmpAirInletNode && HeatingCoilInletNode != 0 && this->m_FanExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     if (this->OAMixerExists) {
                         ShowContinueError(state,
                                           "When a draw through fan is specified, the heating coil inlet node name must be the same as the unitary "
@@ -6268,14 +5751,14 @@ namespace UnitarySystems {
                     errorsFound = true;
                 }
                 if (HeatingCoilOutletNode != CoolingCoilInletNode && this->m_HeatCoilExists && this->m_CoolCoilExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "The heating coil outlet node name must be the same as the cooling coil inlet node name.");
                     ShowContinueError(state, format("...Heating coil outlet node name = {}", state.dataLoopNodes->NodeID(HeatingCoilOutletNode)));
                     ShowContinueError(state, format("...Cooling coil inlet node name  = {}", state.dataLoopNodes->NodeID(CoolingCoilInletNode)));
                     errorsFound = true;
                 }
                 if (CoolingCoilOutletNode != FanInletNode && this->m_CoolCoilExists && this->m_FanExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "When a draw through fan is specified, the cooling coil outlet node name must be the same as the fan "
                                       "inlet node name.");
@@ -6284,7 +5767,7 @@ namespace UnitarySystems {
                     errorsFound = true;
                 }
                 if (FanOutletNode != this->AirOutNode && this->m_FanExists) {
-                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "When a draw through fan is specified, the fan outlet node name must be the same as the unitary system "
                                       "outlet node name.");
@@ -6327,7 +5810,7 @@ namespace UnitarySystems {
         }
         if (this->m_SuppCoilExists) {
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, this->m_HeatingCoilName, this->m_MaxOATSuppHeat);
+                state, state.dataOutRptPredefined->pdchDXHeatCoilSuppHiT, this->m_HeatCoilName, this->m_MaxOATSuppHeat);
         }
 
         if (this->m_MaxCoolAirVolFlow > 0.0 && this->m_MaxHeatAirVolFlow > 0.0 && this->m_MaxNoCoolHeatAirVolFlow >= 0.0 &&
@@ -6352,10 +5835,10 @@ namespace UnitarySystems {
                 } else if (this->m_CoolCoilExists) {
                     this->m_MaxHeatAirVolFlow = this->m_MaxCoolAirVolFlow;
                 } else {
-                    if (this->m_HeatingCoilType_Num != HVAC::CoilDX_HeatingEmpirical &&
-                        this->m_HeatingCoilType_Num != HVAC::CoilDX_MultiSpeedHeating &&
-                        this->m_HeatingCoilType_Num != HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                    if (this->m_heatCoilType != HVAC::CoilType::HeatingDXSingleSpeed &&
+                        this->m_heatCoilType != HVAC::CoilType::HeatingDXMultiSpeed &&
+                        this->m_heatCoilType != HVAC::CoilType::HeatingDXVariableSpeed) {
+                        ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                         ShowContinueError(state,
                                           "When non-DX heating coils are specified, the heating air flow rate must be entered in Heating "
                                           "Supply Air Flow Rate Method");
@@ -6363,7 +5846,7 @@ namespace UnitarySystems {
                     }
                 }
             } else if (this->m_MaxHeatAirVolFlow == 0.0 && !this->m_FanExists && !this->m_CoolCoilExists) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state,
                                   "When non-DX heating coils are specified, the heating air flow rate must be entered in Heating "
                                   "Supply Air Flow Rate Method");
@@ -6372,7 +5855,7 @@ namespace UnitarySystems {
 
         if (FanVolFlowRate != DataSizing::AutoSize && this->m_FanExists) {
             if (FanVolFlowRate < this->m_MaxCoolAirVolFlow && this->m_MaxCoolAirVolFlow != DataSizing::AutoSize && this->m_CoolCoilExists) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(
                     state,
                     format("... air flow rate = {:.7T} in fan object {} is less than the maximum HVAC system air flow rate in cooling mode.",
@@ -6383,7 +5866,7 @@ namespace UnitarySystems {
                 this->m_DesignFanVolFlowRate = FanVolFlowRate;
             }
             if (FanVolFlowRate < this->m_MaxHeatAirVolFlow && this->m_MaxHeatAirVolFlow != DataSizing::AutoSize && this->m_HeatCoilExists) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(
                     state,
                     format("... air flow rate = {:.7T} in fan object {} is less than the maximum HVAC system air flow rate in heating mode.",
@@ -6412,53 +5895,41 @@ namespace UnitarySystems {
         // Set minimum OAT for heat pump compressor operation in cooling mode
         // get from coil module
         errFlag = false;
-        if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-            this->m_MinOATCompressorCooling = DXCoils::GetMinOATCompressor(state, this->m_CoolingCoilIndex, errFlag);
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
-            this->m_MinOATCompressorCooling = DXCoils::GetMinOATCompressor(state, this->m_CoolingCoilIndex, errFlag);
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
-            this->m_MinOATCompressorCooling = DXCoils::GetMinOATCompressor(state, this->m_CoolingCoilIndex, errFlag);
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
-            this->m_MinOATCompressorCooling = DXCoils::GetMinOATCompressor(state, this->m_CoolingCoilIndex, errFlag);
-        } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            this->m_MinOATCompressorCooling = VariableSpeedCoils::GetVSCoilMinOATCompressor(state, this->m_CoolingCoilIndex, errFlag);
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+        if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed ||
+            this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed || 
+            this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+            this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
+            this->m_MinOATCompressorCooling = DXCoils::GetCoilMinOATCompressor(state, this->m_CoolCoilNum);
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            this->m_MinOATCompressorCooling = VariableSpeedCoils::GetCoilMinOATCompressor(state, this->m_CoolCoilNum);
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) {
             // already found in getInput
+            // So why are the other ones not found in GetInput?
         } else {
             this->m_MinOATCompressorCooling = -1000.0;
         }
-        if (errFlag) {
-            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-            errorsFound = true;
-            errFlag = false;
-        }
 
         // Set minimum OAT for heat pump compressor operation in heating mode
         // get from coil module
-        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-            this->m_MinOATCompressorHeating = VariableSpeedCoils::GetVSCoilMinOATCompressor(state, this->m_HeatingCoilIndex, errFlag);
-        } else if (this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical || this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
-            this->m_MinOATCompressorHeating = DXCoils::GetMinOATCompressor(state, this->m_HeatingCoilIndex, errFlag);
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+            this->m_MinOATCompressorHeating = VariableSpeedCoils::GetCoilMinOATCompressor(state, this->m_HeatCoilNum);
+        } else if (this->m_heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+                   this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+            this->m_MinOATCompressorHeating = DXCoils::GetCoilMinOATCompressor(state, this->m_HeatCoilNum);
         } else {
             this->m_MinOATCompressorHeating = -1000.0;
         }
-        if (errFlag) {
-            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
-            errorsFound = true;
-            errFlag = false;
-        }
 
         //       Mine heatpump Outdoor condenser node from DX coil object
-        if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
-            this->m_CondenserNodeNum =
-                DXCoils::GetCoilCondenserInletNode(state, input_data.cooling_coil_object_type, this->m_CoolingCoilName, errFlag);
+        if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
+            this->m_CondenserNodeNum = DXCoils::GetCoilCondenserInletNode(state, this->m_CoolCoilNum);
             // TODO: Should we add a block for the new DX Coil?
-        } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            this->m_CondenserNodeNum = VariableSpeedCoils::GetVSCoilCondenserInletNode(state, this->m_CoolingCoilName, errFlag);
-        } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            this->m_CondenserNodeNum = VariableSpeedCoils::GetCoilCondenserInletNode(state, this->m_CoolCoilNum);
+        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
             // already filled
             // UnitarySystem( UnitarySysNum ).CondenserNodeNum = GetDXCoilCondenserInletNode( "Coil:Cooling:DX:SingleSpeed",
-            // GetHXDXCoilName(state,  CoolingCoilType, this->m_CoolingCoilName, errFlag ), errFlag );
+            // GetHXDXCoilName(state,  CoolingCoilType, this->m_CoolCoilName, errFlag ), errFlag );
 
         } else {
             if (input_data.outdoor_dry_bulb_temperature_sensor_node_name != "") {
@@ -6466,7 +5937,7 @@ namespace UnitarySystems {
                                                                                input_data.outdoor_dry_bulb_temperature_sensor_node_name,
                                                                                errFlag,
                                                                                objType,
-                                                                               thisObjectName,
+                                                                               this->Name,
                                                                                DataLoopNode::NodeFluidType::Air,
                                                                                DataLoopNode::ConnectionType::Inlet,
                                                                                NodeInputManager::CompFluidStream::Primary,
@@ -6476,7 +5947,7 @@ namespace UnitarySystems {
             }
         }
         if (errFlag) {
-            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+            ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, this->Name));
             errorsFound = true;
             errFlag = false;
         }
@@ -6492,7 +5963,7 @@ namespace UnitarySystems {
                                                                                        input_data.heat_recovery_water_inlet_node_name,
                                                                                        errFlag,
                                                                                        objType,
-                                                                                       thisObjectName,
+                                                                                       this->Name,
                                                                                        DataLoopNode::NodeFluidType::Water,
                                                                                        DataLoopNode::ConnectionType::Inlet,
                                                                                        NodeInputManager::CompFluidStream::Tertiary,
@@ -6501,7 +5972,7 @@ namespace UnitarySystems {
                                                                                         input_data.heat_recovery_water_outlet_node_name,
                                                                                         errFlag,
                                                                                         objType,
-                                                                                        thisObjectName,
+                                                                                        this->Name,
                                                                                         DataLoopNode::NodeFluidType::Water,
                                                                                         DataLoopNode::ConnectionType::Outlet,
                                                                                         NodeInputManager::CompFluidStream::Tertiary,
@@ -6509,24 +5980,24 @@ namespace UnitarySystems {
 
                 BranchNodeConnections::TestCompSet(state,
                                                    cCurrentModuleObject,
-                                                   thisObjectName,
+                                                   this->Name,
                                                    input_data.heat_recovery_water_inlet_node_name,
                                                    input_data.heat_recovery_water_outlet_node_name,
                                                    "Unitary System Heat Recovery Nodes");
 
-                if (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
-                    DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, this->m_CoolingCoilIndex);
+                if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
+                    DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, this->m_CoolCoilNum);
                 }
-                if (this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
-                    DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, this->m_HeatingCoilIndex);
+                if (this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
+                    DXCoils::SetMSHPDXCoilHeatRecoveryFlag(state, this->m_HeatCoilNum);
                 }
                 if (errFlag) {
-                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                    ShowContinueError(state, format("Occurs in {} = {}", cCurrentModuleObject, this->Name));
                     errorsFound = true;
                     // errFlag = false; // not used after this point, uncomment if needed
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, format("Illegal Heat Recovery Water Inlet Node Name = {}", input_data.heat_recovery_water_inlet_node_name));
                 ShowContinueError(state,
                                   format("Illegal Heat Recovery Water Outlet Node Name = {}", input_data.heat_recovery_water_outlet_node_name));
@@ -6544,12 +6015,12 @@ namespace UnitarySystems {
 
                 this->m_NoLoadAirFlowRateRatio = this->m_CompPointerMSHP->noLoadAirFlowRateRatio;
 
-                switch (this->m_HeatingCoilType_Num) {
-                case HVAC::CoilDX_MultiSpeedHeating:
-                case HVAC::Coil_HeatingElectric_MultiStage:
-                case HVAC::Coil_HeatingGas_MultiStage:
-                case HVAC::Coil_HeatingWaterToAirHPSimple:
-                case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+                switch (this->m_heatCoilType) {
+                case HVAC::CoilType::HeatingDXMultiSpeed:
+                case HVAC::CoilType::HeatingElectricMultiStage:
+                case HVAC::CoilType::HeatingGasMultiStage:
+                case HVAC::CoilType::HeatingWAHPSimple:
+                case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
                     this->m_NumOfSpeedHeating = this->m_CompPointerMSHP->numOfSpeedHeating;
                     this->m_HeatMassFlowRate.resize(this->m_NumOfSpeedHeating + 1);
                     this->m_HeatVolumeFlowRate.resize(this->m_NumOfSpeedHeating + 1);
@@ -6557,7 +6028,7 @@ namespace UnitarySystems {
                     if (state.dataGlobal->DoCoilDirectSolutions && this->m_NumOfSpeedCooling < this->m_NumOfSpeedHeating) {
                         this->FullOutput.resize(this->m_NumOfSpeedHeating + 1);
                     }
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple && this->m_NumOfSpeedHeating > 1) {
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple && this->m_NumOfSpeedHeating > 1) {
                         this->m_MultiSpeedHeatingCoil = true;
                         this->m_MultiOrVarSpeedHeatCoil = true;
                     }
@@ -6566,15 +6037,11 @@ namespace UnitarySystems {
                         this->m_HeatVolumeFlowRate[i] = 0.0;
                         this->m_MSHeatingSpeedRatio[i] = 1.0;
                     }
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                         std::string MultispeedType = (this->m_DesignSpecMSHPIndex == -1) ? "Fan:SystemModel" : "UnitarySystemPerformance:Multispeed";
-                        int NumOfSpeed = VariableSpeedCoils::GetVSCoilNumOfSpeeds(state, this->m_HeatingCoilName, errorsFound);
-                        if (errorsFound) {
-                            ShowSevereError(state,
-                                            format("{} = {} is not found. Please check the input.", cCurrentModuleObject, this->m_HeatingCoilName));
-                        }
+                        int NumOfSpeed = VariableSpeedCoils::GetCoilNumOfSpeeds(state, this->m_HeatCoilNum);
                         if (NumOfSpeed != this->m_NumOfSpeedHeating) {
-                            ShowWarningError(state, format("{} = {}.", cCurrentModuleObject, this->m_HeatingCoilName));
+                            ShowWarningError(state, format("{} = {}.", cCurrentModuleObject, this->m_HeatCoilName));
                             ShowContinueError(state,
                                               format("... The number of heating coil speeds in the {} = {:.0R}",
                                                      MultispeedType,
@@ -6588,19 +6055,19 @@ namespace UnitarySystems {
                     }
                 } break;
                 }
-                switch (this->m_CoolingCoilType_Num) {
-                case HVAC::CoilDX_MultiSpeedCooling:
-                case HVAC::Coil_CoolingWaterToAirHPSimple:
-                case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
+                switch (this->m_coolCoilType) {
+                case HVAC::CoilType::CoolingDXMultiSpeed:
+                case HVAC::CoilType::CoolingWAHPSimple:
+                case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
                     this->m_NumOfSpeedCooling = this->m_CompPointerMSHP->numOfSpeedCooling;
                     this->m_CoolMassFlowRate.resize(this->m_NumOfSpeedCooling + 1);
                     this->m_CoolVolumeFlowRate.resize(this->m_NumOfSpeedCooling + 1);
                     this->m_MSCoolingSpeedRatio.resize(this->m_NumOfSpeedCooling + 1);
                     if (state.dataGlobal->DoCoilDirectSolutions && this->m_NumOfSpeedCooling > this->m_NumOfSpeedHeating) {
                         this->FullOutput.resize(this->m_NumOfSpeedCooling + 1);
-                        DXCoils::DisableLatentDegradation(state, this->m_CoolingCoilIndex);
+                        DXCoils::DisableLatentDegradation(state, this->m_CoolCoilNum);
                     }
-                    if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple && this->m_NumOfSpeedCooling > 1) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple && this->m_NumOfSpeedCooling > 1) {
                         this->m_MultiOrVarSpeedCoolCoil = true;
                         this->m_DiscreteSpeedCoolingCoil = true;
                     }
@@ -6609,15 +6076,11 @@ namespace UnitarySystems {
                         this->m_CoolVolumeFlowRate[i] = 0.0;
                         this->m_MSCoolingSpeedRatio[i] = 1.0;
                     }
-                    if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
                         std::string MultispeedType = (this->m_DesignSpecMSHPIndex == -1) ? "Fan:SystemModel" : "UnitarySystemPerformance:Multispeed";
-                        int NumOfSpeed = VariableSpeedCoils::GetVSCoilNumOfSpeeds(state, this->m_CoolingCoilName, errorsFound);
-                        if (errorsFound) {
-                            ShowSevereError(state,
-                                            format("{} = {} is not found. Please check the input.", cCurrentModuleObject, this->m_CoolingCoilName));
-                        }
+                        int NumOfSpeed = VariableSpeedCoils::GetCoilNumOfSpeeds(state, this->m_CoolCoilNum);
                         if (NumOfSpeed != this->m_NumOfSpeedCooling) {
-                            ShowWarningError(state, format("{} = {}.", cCurrentModuleObject, this->m_CoolingCoilName));
+                            ShowWarningError(state, format("{} = {}.", cCurrentModuleObject, this->m_CoolCoilName));
                             ShowContinueError(state,
                                               format("... The number of Cooling coil speeds in the {} = {:.0R}",
                                                      MultispeedType,
@@ -6632,7 +6095,7 @@ namespace UnitarySystems {
                 } break;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, "... one or both of the following inputs are invalid.");
                 ShowContinueError(state, format("Field Design Specification Multispeed Object Type = {}", this->m_DesignSpecMultispeedHPType));
                 ShowContinueError(state, format("Field Design Specification Multispeed Object Name = {}", this->m_DesignSpecMultispeedHPName));
@@ -6644,8 +6107,8 @@ namespace UnitarySystems {
                 assert(fanSystem != nullptr);
                 if (fanSystem->speedControl == Fans::SpeedControl::Discrete) {
                     if (fanSystem->numSpeeds > 1) {
-                        if ((this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple ||
-                             this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) &&
+                        if ((this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple ||
+                             this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) &&
                             this->m_sysType == SysType::PackagedWSHP) {
                             this->m_NumOfSpeedCooling = fanSystem->numSpeeds;
                             this->m_CoolVolumeFlowRate.resize(fanSystem->numSpeeds + 1);
@@ -6669,8 +6132,8 @@ namespace UnitarySystems {
                                 }
                             }
                         }
-                        if ((this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                             this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) &&
+                        if ((this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple ||
+                             this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) &&
                             this->m_sysType == SysType::PackagedWSHP) {
                             this->m_NumOfSpeedHeating = fanSystem->numSpeeds;
                             this->m_HeatVolumeFlowRate.resize(fanSystem->numSpeeds + 1);
@@ -6694,11 +6157,11 @@ namespace UnitarySystems {
                                 }
                             }
                         }
-                        if (((this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple ||
-                              this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) &&
+                        if (((this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple ||
+                              this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) &&
                              this->m_sysType == SysType::PackagedWSHP) ||
-                            ((this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                              this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) &&
+                            ((this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple ||
+                              this->m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) &&
                              this->m_sysType == SysType::PackagedWSHP)) {
                             ShowWarningError(state,
                                              format("{} = {} with Fan:SystemModel is used in \"{}\"",
@@ -6713,7 +6176,7 @@ namespace UnitarySystems {
             }
         } else if ((this->m_DesignSpecMultispeedHPType.empty() && !this->m_DesignSpecMultispeedHPName.empty()) ||
                    (!this->m_DesignSpecMultispeedHPType.empty() && this->m_DesignSpecMultispeedHPName.empty())) {
-            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+            ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
             ShowContinueError(state, "... one or both of the following inputs are invalid.");
             ShowContinueError(state, format("Field Design Specification Multispeed Object Type = {}", this->m_DesignSpecMultispeedHPType));
             ShowContinueError(state, format("Field Design Specification Multispeed Object Name = {}", this->m_DesignSpecMultispeedHPName));
@@ -6723,7 +6186,7 @@ namespace UnitarySystems {
         if (this->m_DiscreteSpeedCoolingCoil) {
 
             if (this->m_NumOfSpeedCooling == 0) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state,
                                   format("... Cooling coil object type requires valid {} for cooling to be specified with number of speeds > 0",
                                          unitarySysHeatPumpPerformanceObjectType));
@@ -6735,7 +6198,7 @@ namespace UnitarySystems {
             if (this->m_DesignSpecMSHPIndex > -1) this->m_NumOfSpeedHeating = this->m_CompPointerMSHP->numOfSpeedHeating;
 
             if (this->m_NumOfSpeedHeating == 0) {
-                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state,
                                   format("... Heating coil object type requires valid {} for heating to be specified with number of speeds > 0",
                                          unitarySysHeatPumpPerformanceObjectType));
@@ -6743,10 +6206,10 @@ namespace UnitarySystems {
             }
         }
 
-        if ((this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating &&
-             (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling || this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling)) ||
-            (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel &&
-             (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling || this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling))) {
+        if ((this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed &&
+             (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed || this->m_coolCoilType == HVAC::CoilType::CoolingDX)) ||
+            (this->m_heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel &&
+             (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed || this->m_coolCoilType == HVAC::CoilType::CoolingDX))) {
             if (this->m_DesignSpecMSHPIndex > -1) {
                 if (this->m_CompPointerMSHP->m_SingleModeFlag) {
                     this->m_SingleMode = 1;
@@ -6755,24 +6218,24 @@ namespace UnitarySystems {
         } else {
             if (this->m_DesignSpecMSHPIndex > -1) {
                 if (this->m_CompPointerMSHP->m_SingleModeFlag) {
-                    ShowSevereError(state, format("{}: {}", cCurrentModuleObject, thisObjectName));
+                    ShowSevereError(state, format("{}: {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state,
                                       "In order to perform Single Mode Operation, the valid cooling coil type is Coil:Cooling:DX:MultiSpeed "
                                       "or Coil:Cooling:DX and the valid heating is Coil:Heating:DX:MultiSpeed or Coil:Heating:Fuel.");
                     ShowContinueError(state,
                                       format("The input cooling coil type = {} and the input heating coil type = {}",
                                              input_data.cooling_coil_object_type,
-                                             this->m_HeatingCoilTypeName));
+                                             HVAC::coilTypeNames[(int)this->m_heatCoilType]));
                 }
             }
         }
 
-        if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            VariableSpeedCoils::SetVarSpeedCoilData(state, this->m_CoolingCoilIndex, errorsFound, _, _, this->m_DesignSpecMSHPIndex);
+        if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            VariableSpeedCoils::SetCoilData(state, this->m_CoolCoilNum, _, _, this->m_DesignSpecMSHPIndex);
         }
 
-        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-            VariableSpeedCoils::SetVarSpeedCoilData(state, this->m_HeatingCoilIndex, errorsFound, _, _, this->m_DesignSpecMSHPIndex);
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+            VariableSpeedCoils::SetCoilData(state, this->m_HeatCoilNum, _, _, this->m_DesignSpecMSHPIndex);
         }
 
         // set global logicals that denote coil type
@@ -6784,7 +6247,7 @@ namespace UnitarySystems {
         }
 
         // set global variables for multi-stage chilled and hot water coils
-        if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
+        if (this->m_coolCoilType == HVAC::CoilType::CoolingWater || this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
             if (this->m_DesignSpecMSHPIndex > -1) {
                 this->m_NumOfSpeedCooling = this->m_CompPointerMSHP->numOfSpeedCooling;
                 if (this->m_NumOfSpeedCooling > 1) {
@@ -6793,7 +6256,7 @@ namespace UnitarySystems {
                 }
             }
         }
-        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
             // designSpecIndex = this->m_DesignSpecMSHPIndex;
             if (this->m_DesignSpecMSHPIndex > -1) {
                 this->m_NumOfSpeedHeating = this->m_CompPointerMSHP->numOfSpeedHeating;
@@ -6819,10 +6282,10 @@ namespace UnitarySystems {
         if (this->m_ControlType == UnitarySysCtrlType::CCMASHRAE) {
 
             // only allowed for water and DX cooling coils at this time
-            if (this->m_CoolCoilExists && this->m_CoolingCoilType_Num != HVAC::Coil_CoolingWater &&
-                this->m_CoolingCoilType_Num != HVAC::Coil_CoolingWaterDetailed && this->m_CoolingCoilType_Num != HVAC::CoilDX_CoolingSingleSpeed) {
+            if (this->m_CoolCoilExists && this->m_coolCoilType != HVAC::CoilType::CoolingWater &&
+                this->m_coolCoilType != HVAC::CoilType::CoolingWaterDetailed && this->m_coolCoilType != HVAC::CoilType::CoolingDXSingleSpeed) {
                 if (state.dataGlobal->DisplayExtraWarnings) {
-                    ShowWarningError(state, format("{}: {}", cCurrentModuleObject, thisObjectName));
+                    ShowWarningError(state, format("{}: {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "ASHRAE90.1 control method requires specific cooling coil types.");
                     ShowContinueError(state,
                                       "Valid cooling coil types are Coil:Cooling:Water, Coil:Cooling:Water:DetailedGeometry and "
@@ -6835,24 +6298,26 @@ namespace UnitarySystems {
                 this->m_ValidASHRAECoolCoil = false;
             }
             // only allow for water, fuel, or electric at this time
-            if (this->m_HeatCoilExists && this->m_HeatingCoilType_Num != HVAC::Coil_HeatingWater &&
-                this->m_HeatingCoilType_Num != HVAC::Coil_HeatingGasOrOtherFuel && this->m_HeatingCoilType_Num != HVAC::Coil_HeatingElectric &&
-                this->m_HeatingCoilType_Num != HVAC::CoilDX_HeatingEmpirical) {
+            if (this->m_HeatCoilExists &&
+                this->m_heatCoilType != HVAC::CoilType::HeatingWater &&
+                this->m_heatCoilType != HVAC::CoilType::HeatingGasOrOtherFuel &&
+                this->m_heatCoilType != HVAC::CoilType::HeatingElectric &&
+                this->m_heatCoilType != HVAC::CoilType::HeatingDXSingleSpeed) {
                 if (state.dataGlobal->DisplayExtraWarnings) {
-                    ShowWarningError(state, format("{}: {}", cCurrentModuleObject, thisObjectName));
+                    ShowWarningError(state, format("{}: {}", cCurrentModuleObject, this->Name));
                     ShowContinueError(state, "ASHRAE90.1 control method requires specific heating coil types.");
                     ShowContinueError(state,
                                       "Valid heating coil types are Coil:Heating:Water, Coil:Heating:Fuel, Coil:Heating:Electric and "
                                       "Coil:Heating:DX:SingleSpeed.");
                     ShowContinueError(state,
                                       format("The input heating coil type = {}. This coil will not be modeled using the ASHRAE 90.1 algorithm.",
-                                             this->m_HeatingCoilTypeName));
+                                             HVAC::coilTypeNames[(int)this->m_heatCoilType]));
                 }
                 // mark this coil as non-ASHRAE90 type
                 this->m_ValidASHRAEHeatCoil = false;
             }
             if (this->m_DehumidControlType_Num == DehumCtrlType::Multimode || this->m_DehumidControlType_Num == DehumCtrlType::CoolReheat) {
-                ShowWarningError(state, format("{}: {}", cCurrentModuleObject, thisObjectName));
+                ShowWarningError(state, format("{}: {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, format("Invalid entry for Dehumidification Control Type = {}", input_data.dehumidification_control_type));
                 ShowContinueError(state,
                                   "ASHRAE90.1 control method does not support dehumidification at this time. Dehumidification control type is "
@@ -6860,7 +6325,7 @@ namespace UnitarySystems {
                 this->m_DehumidControlType_Num = DehumCtrlType::None;
             }
             if (this->m_RunOnLatentLoad) {
-                ShowWarningError(state, format("{} = {}", cCurrentModuleObject, thisObjectName));
+                ShowWarningError(state, format("{} = {}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, format("Invalid entry for Latent Load Control: {}", input_data.latent_load_control));
                 ShowContinueError(state,
                                   "ASHRAE90.1 control method does not support latent load control at this time. This input must be selected as "
@@ -6870,7 +6335,7 @@ namespace UnitarySystems {
                 this->m_RunOnLatentOnlyWithSensible = false;
             }
             if (this->m_MaxNoCoolHeatAirVolFlow == 0.0) { // 0 min air flow not allowed for SZVAV
-                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, thisObjectName));
+                ShowSevereError(state, format("Input errors for {}:{}", cCurrentModuleObject, this->Name));
                 ShowContinueError(state, format("Control Type = {}", input_data.control_type));
                 ShowContinueError(state, "Input for No Load Supply Air Flow Rate cannot be 0.");
                 errorsFound = true;
@@ -6888,24 +6353,37 @@ namespace UnitarySystems {
             int numCoilSystemDX = 0;
             for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
 
-                std::string const &thisObjectName = Util::makeUPPER(instance.key());
+                auto const &objName = instance.key();
+                std::string objNameUC = Util::makeUPPER(objName);
                 // only get the current data once all data has been read in and vector unitarySys has been initialized
                 // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the current object
-                if (!Util::SameString(objectName, thisObjectName) && !state.dataUnitarySystems->getInputOnceFlag) continue;
+                if (objNameUC != Util::makeUPPER(objectName) && !state.dataUnitarySystems->getInputOnceFlag) continue;
+
+                int sysNum = getUnitarySystemIndex(state, objNameUC);
 
-                int sysNum = getUnitarySystemIndex(state, thisObjectName);
+                // TODO: This is not good and needs to be fixed at some
+                // point.  Unitary systems objects are populated in
+                // multiple passes.  This not only involves reading
+                // and processing chunks of the input multiple times
+                // but also copying the entire UnitarySystem object
+                // into a giant local variable and then copying it
+                // back.
                 UnitarySys thisSys;
                 if (sysNum == -1) {
                     ++state.dataUnitarySystems->numUnitarySystems;
-                    auto const &thisObjName = instance.key();
-                    state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, thisObjName);
+                    state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, objName);
                 } else {
                     thisSys = state.dataUnitarySystems->unitarySys[sysNum];
                 }
 
                 // get CoilSystem:Cooling:DX object inputs
                 auto const &fields = instance.value();
-                thisSys.input_specs.name = thisObjectName;
+
+                // What is the point of constructing this string-based
+                // input_spec object only to immediately pass it to an
+                // function that will construct the actual object from
+                // it?
+                thisSys.input_specs.name = objNameUC;
                 thisSys.input_specs.system_type = cCurrentModuleObject;
                 if (auto it = fields.find("availability_schedule_name"); it != fields.end()) { // not required field
                     thisSys.input_specs.availability_schedule_name = Util::makeUPPER(it.value().get<std::string>());
@@ -6974,6 +6452,8 @@ namespace UnitarySystems {
                 thisSys.m_LastMode = CoolingMode;
                 thisSys.processInputSpec(state, thisSys.input_specs, sysNum, errorsFound, ZoneEquipment, ZoneOAUnitNum);
 
+                // TODO: copy entire unitary system object back to the
+                // array on the second initialization pass
                 if (sysNum == -1) {
                     int thisSysNum = state.dataUnitarySystems->numUnitarySystems - 1;
                     state.dataUnitarySystems->unitarySys[thisSysNum] = thisSys;
@@ -7014,24 +6494,24 @@ namespace UnitarySystems {
                 auto const &objectSchemaProps = ip->getObjectSchemaProps(state, cCurrentModuleObject);
                 for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
 
-                    std::string const &thisObjectName = Util::makeUPPER(instance.key());
+                    std::string const &objName = instance.key();
+                    std::string objNameUC = Util::makeUPPER(objName);
                     // only get the current data once all data has been read in and vector unitarySys has been initialized
                     // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the current object
-                    if (!Util::SameString(objectName, thisObjectName) && !state.dataUnitarySystems->getInputOnceFlag) continue;
+                    if (Util::makeUPPER(objectName) != objNameUC && !state.dataUnitarySystems->getInputOnceFlag) continue;
 
-                    int sysNum = getUnitarySystemIndex(state, thisObjectName);
+                    int sysNum = getUnitarySystemIndex(state, objNameUC);
                     UnitarySys thisSys;
                     if (sysNum == -1) {
                         ++state.dataUnitarySystems->numUnitarySystems;
-                        auto const &thisObjName = instance.key();
-                        state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, thisObjName);
+                        state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, objName);
                     } else {
                         thisSys = state.dataUnitarySystems->unitarySys[sysNum];
                     }
 
                     // get PackagedTerminal unit object inputs
                     auto const &fields = instance.value();
-                    thisSys.input_specs.name = thisObjectName;
+                    thisSys.input_specs.name = objName;
                     thisSys.input_specs.system_type = cCurrentModuleObject;
                     thisSys.input_specs.availability_schedule_name = ip->getAlphaFieldValue(fields, objectSchemaProps, "availability_schedule_name");
                     thisSys.input_specs.air_inlet_node_name = ip->getAlphaFieldValue(fields, objectSchemaProps, "air_inlet_node_name");
@@ -7144,8 +6624,8 @@ namespace UnitarySystems {
                         default:
                             assert(true);
                         }
-                        int thisSysNum = state.dataUnitarySystems->numUnitarySystems - 1;
-                        state.dataUnitarySystems->unitarySys[thisSysNum] = thisSys;
+                        
+                        state.dataUnitarySystems->unitarySys[state.dataUnitarySystems->numUnitarySystems - 1] = thisSys;
                     } else {
                         state.dataUnitarySystems->unitarySys[sysNum] = thisSys;
                     }
@@ -7164,10 +6644,7 @@ namespace UnitarySystems {
         int numPackagedHP = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "ZoneHVAC:PackagedTerminalHeatPump");
         int numPackagedWSHP = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "ZoneHVAC:WaterToAirHeatPump");
         int numAllSystemTypes = numUnitarySystems + numCoilSystems + numCoilSystemsWater + numPackagedAC + numPackagedHP + numPackagedWSHP;
-        for (int sysCount = 0; sysCount < numAllSystemTypes; ++sysCount) {
-            UnitarySys thisSys;
-            state.dataUnitarySystems->unitarySys.push_back(thisSys);
-        }
+        state.dataUnitarySystems->unitarySys.resize(numAllSystemTypes);
     }
 
     void UnitarySys::getCoilWaterSystemInputData(
@@ -7175,28 +6652,33 @@ namespace UnitarySystems {
     {
 
         std::string cCurrentModuleObject("CoilSystem:Cooling:Water");
-        static const std::string routineName("getCoilWaterSystemInputData: ");
+        static constexpr std::string_view routineName = "getCoilWaterSystemInputData";
+
+        ErrorObjectHeader eoh{routineName, cCurrentModuleObject, CoilSysName};
+        
         auto const instances = state.dataInputProcessing->inputProcessor->epJSON.find(cCurrentModuleObject);
         if (instances != state.dataInputProcessing->inputProcessor->epJSON.end()) {
             auto &instancesValue = instances.value();
             int numCoilSystemWater = 0;
             for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
 
-                auto const &fields = instance.value();
-                std::string const &thisObjectName = Util::makeUPPER(instance.key());
-                if (!Util::SameString(CoilSysName, thisObjectName) && !state.dataUnitarySystems->getInputOnceFlag) continue;
-
-                int sysNum = getUnitarySystemIndex(state, thisObjectName);
+                auto const &objName = instance.key();
+                std::string objNameUC = Util::makeUPPER(objName);
+                
+                if (Util::makeUPPER(CoilSysName) != objNameUC && !state.dataUnitarySystems->getInputOnceFlag) continue;
+                
+                int sysNum = getUnitarySystemIndex(state, objName);
                 UnitarySys thisSys;
                 if (sysNum == -1) {
                     ++state.dataUnitarySystems->numUnitarySystems;
-                    auto const &thisObjName = instance.key();
-                    state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, thisObjName);
+                    state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, objName);
                 } else {
                     thisSys = state.dataUnitarySystems->unitarySys[sysNum];
                 }
+                              
+                auto const &fields = instance.value();
 
-                thisSys.input_specs.name = thisObjectName;
+                thisSys.input_specs.name = objNameUC;
                 thisSys.input_specs.system_type = cCurrentModuleObject;
                 thisSys.input_specs.control_type = "Setpoint";
                 thisSys.input_specs.air_inlet_node_name = Util::makeUPPER(fields.at("air_inlet_node_name").get<std::string>());
@@ -7265,25 +6747,23 @@ namespace UnitarySystems {
                 } else {
                     thisSys.m_waterSideEconomizerFlag = true;
                 }
-                std::string HRWaterCoolingCoilName;
+
                 if (auto it = fields.find("companion_coil_used_for_heat_recovery"); it != fields.end()) {
-                    HRWaterCoolingCoilName = Util::makeUPPER(it.value().get<std::string>());
+                    thisSys.m_HRcoolCoilName = Util::makeUPPER(it.value().get<std::string>());
                     thisSys.m_WaterHRPlantLoopModel = true;
                 }
                 if (thisSys.m_WaterHRPlantLoopModel) {
-                    std::string const HRcoolingCoilType("COIL:COOLING:WATER");
                     bool errFound = false;
-                    thisSys.m_HRcoolCoilAirInNode = WaterCoils::GetCoilInletNode(state, HRcoolingCoilType, HRWaterCoolingCoilName, errFound);
-                    thisSys.m_HRcoolCoilFluidInletNode =
-                        WaterCoils::GetCoilWaterInletNode(state, HRcoolingCoilType, HRWaterCoolingCoilName, errFound);
-                    int HRCoilIndex = WaterCoils::GetWaterCoilIndex(state, Util::makeUPPER(HRcoolingCoilType), HRWaterCoolingCoilName, errFound);
-                    bool heatRecoveryCoil = true; // use local here to highlight where this parameter is set
-                    WaterCoils::SetWaterCoilData(state, HRCoilIndex, errFound, _, _, heatRecoveryCoil);
-                    if (errFound) {
-                        if (HRCoilIndex == 0) {
-                            ShowContinueError(state, format("...cooling coil {} must be of type Coil:Cooling:Water.", HRWaterCoolingCoilName));
-                        }
-                        ShowContinueError(state, format("...occurs in {} = {}", cCurrentModuleObject, thisObjectName));
+                    thisSys.m_HRcoolCoilNum = WaterCoils::GetCoilIndex(state, thisSys.m_HRcoolCoilName);
+                    if (thisSys.m_HRcoolCoilNum == 0) {
+                        ShowSevereItemNotFound(state, eoh, "companion_coil_used_for_heat_recovery", thisSys.m_HRcoolCoilName);
+                        errFound = true;
+                    } else {
+                        thisSys.m_HRcoolCoilAirInNode = WaterCoils::GetCoilAirInletNode(state, thisSys.m_HRcoolCoilNum);
+                        thisSys.m_HRcoolCoilFluidInletNode = WaterCoils::GetCoilWaterInletNode(state, thisSys.m_HRcoolCoilNum);
+
+                        bool heatRecoveryCoil = true; // use local here to highlight where this parameter is set
+                        WaterCoils::SetWaterCoilData(state, thisSys.m_HRcoolCoilNum, errFound, _, _, heatRecoveryCoil);
                     }
                     errorsFound = errorsFound || errFound;
                 }
@@ -7292,8 +6772,7 @@ namespace UnitarySystems {
                 thisSys.processInputSpec(state, thisSys.input_specs, sysNum, errorsFound, ZoneEquipment, ZoneOAUnitNum);
 
                 if (sysNum == -1) {
-                    int thisSysNum = state.dataUnitarySystems->numUnitarySystems - 1;
-                    state.dataUnitarySystems->unitarySys[thisSysNum] = thisSys;
+                    state.dataUnitarySystems->unitarySys[state.dataUnitarySystems->numUnitarySystems - 1] = thisSys;
                     // zone equipment require a 1-n index for access to zone availability managers
                     // although not zone equipment, use same methodology
                     ++numCoilSystemWater;
@@ -7301,6 +6780,7 @@ namespace UnitarySystems {
                 } else {
                     state.dataUnitarySystems->unitarySys[sysNum] = thisSys;
                 }
+                
             }
 
             if (errorsFound) {
@@ -7329,27 +6809,29 @@ namespace UnitarySystems {
             auto const &objectSchemaProps = state.dataInputProcessing->inputProcessor->getObjectSchemaProps(state, cCurrentModuleObject);
             for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
 
-                std::string const &thisObjectName = Util::makeUPPER(instance.key());
+                std::string const &objName = instance.key();
+                std::string objNameUC = Util::makeUPPER(objName);
+                
                 // only get the current data once all data has been read in and vector unitarySys has been initialized
                 // when UnitarySystems::getInputOnceFlag is true read all unitary systems, otherwise read just the current object
-                if (!Util::SameString(objectName, thisObjectName) && !state.dataUnitarySystems->getInputOnceFlag) continue;
+                if (Util::makeUPPER(objectName) != objNameUC && !state.dataUnitarySystems->getInputOnceFlag) continue;
 
-                int sysNum = getUnitarySystemIndex(state, thisObjectName);
+                int sysNum = getUnitarySystemIndex(state, objNameUC);
                 UnitarySys thisSys;
                 if (sysNum == -1) {
                     ++state.dataUnitarySystems->numUnitarySystems;
-                    auto const &thisObjName = instance.key();
-                    state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, thisObjName);
+                    state.dataInputProcessing->inputProcessor->markObjectAsUsed(cCurrentModuleObject, objName);
                 } else {
                     thisSys = state.dataUnitarySystems->unitarySys[sysNum];
                 }
 
                 auto const &fields = instance.value();
+
                 thisSys.UnitType = cCurrentModuleObject;
                 thisSys.m_sysType = SysType::Unitary;
                 thisSys.AirloopEqType = SimAirServingZones::CompType::UnitarySystemModel;
 
-                thisSys.input_specs.name = thisObjectName;
+                thisSys.input_specs.name = objName;
                 thisSys.input_specs.system_type = cCurrentModuleObject;
                 thisSys.input_specs.control_type = fields.at("control_type").get<std::string>();
                 if (auto it = fields.find("controlling_zone_or_thermostat_location"); it != fields.end()) { // not required field
@@ -7536,8 +7018,8 @@ namespace UnitarySystems {
                         ++airloopUnitaryNum;
                         thisSys.m_EquipCompNum = airloopUnitaryNum;
                     }
-                    int thisSysNum = state.dataUnitarySystems->numUnitarySystems - 1;
-                    state.dataUnitarySystems->unitarySys[thisSysNum] = thisSys;
+                    
+                    state.dataUnitarySystems->unitarySys[state.dataUnitarySystems->numUnitarySystems - 1] = thisSys;
                 } else {
                     state.dataUnitarySystems->unitarySys[sysNum] = thisSys;
                 }
@@ -7559,26 +7041,24 @@ namespace UnitarySystems {
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         Real64 QActual;
 
-        std::string CompName = this->m_SuppHeatCoilName;
-        int CoilType_Num = this->m_SuppHeatCoilType_Num;
-
-        if ((CoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel) || (CoilType_Num == HVAC::Coil_HeatingElectric)) {
+        if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+            this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectric) {
             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                        CompName,
+                                                        this->m_SuppHeatCoilName,
                                                         FirstHVACIteration,
                                                         this->m_DesignSuppHeatingCapacity * this->m_SuppHeatPartLoadFrac,
-                                                        this->m_SuppHeatCoilIndex,
+                                                        this->m_SuppHeatCoilNum,
                                                         _,
                                                         true,
                                                         this->m_FanOpMode,
                                                         this->m_SuppHeatPartLoadFrac);
 
-        } else if (CoilType_Num == HVAC::Coil_HeatingElectric_MultiStage) {
+        } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectricMultiStage) {
             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                        CompName,
+                                                        this->m_SuppHeatCoilName,
                                                         FirstHVACIteration,
                                                         _,
-                                                        this->m_SuppHeatCoilIndex,
+                                                        this->m_SuppHeatCoilNum,
                                                         _,
                                                         _,
                                                         this->m_FanOpMode,
@@ -7586,26 +7066,26 @@ namespace UnitarySystems {
                                                         this->m_SuppHeatingSpeedNum,
                                                         this->m_SuppHeatingSpeedRatio);
 
-        } else if (CoilType_Num == HVAC::Coil_HeatingDesuperheater) {
+        } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingDesuperheater) {
             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                        CompName,
+                                                        this->m_SuppHeatCoilName,
                                                         FirstHVACIteration,
                                                         this->m_DesignSuppHeatingCapacity * this->m_SuppHeatPartLoadFrac,
-                                                        this->m_SuppHeatCoilIndex,
+                                                        this->m_SuppHeatCoilNum,
                                                         _,
                                                         _,
                                                         this->m_FanOpMode,
                                                         this->m_SuppHeatPartLoadFrac);
 
-        } else if (CoilType_Num == HVAC::Coil_HeatingWater) {
+        } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingWater) {
             WaterCoils::SimulateWaterCoilComponents(
-                state, CompName, FirstHVACIteration, this->m_SuppHeatCoilIndex, QActual, this->m_FanOpMode, this->m_SuppHeatPartLoadFrac);
+                state, this->m_SuppHeatCoilName, FirstHVACIteration, this->m_SuppHeatCoilNum, QActual, this->m_FanOpMode, this->m_SuppHeatPartLoadFrac);
 
-        } else if (CoilType_Num == HVAC::Coil_HeatingSteam) {
+        } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingSteam) {
             SteamCoils::SimulateSteamCoilComponents(state,
-                                                    CompName,
+                                                    this->m_SuppHeatCoilName,
                                                     FirstHVACIteration,
-                                                    this->m_SuppHeatCoilIndex,
+                                                    this->m_SuppHeatCoilNum,
                                                     this->m_DesignSuppHeatingCapacity * this->m_SuppHeatPartLoadFrac,
                                                     _,
                                                     this->m_FanOpMode,
@@ -7645,8 +7125,8 @@ namespace UnitarySystems {
         // using furnace module logic
         // first check to see if cycling fan with economizer can meet the load
         if (AirLoopNum > 0) {
-            if (this->m_CoolCoilExists && this->m_HeatCoilExists && this->m_CoolingCoilType_Num != HVAC::Coil_CoolingAirToAirVariableSpeed &&
-                this->m_HeatingCoilType_Num != HVAC::Coil_HeatingAirToAirVariableSpeed && !FirstHVACIteration &&
+            if (this->m_CoolCoilExists && this->m_HeatCoilExists && this->m_coolCoilType != HVAC::CoilType::CoolingDXVariableSpeed &&
+                this->m_heatCoilType != HVAC::CoilType::HeatingDXVariableSpeed && !FirstHVACIteration &&
                 this->m_FanOpMode == HVAC::FanOp::Cycling && state.dataUnitarySystems->CoolingLoad &&
                 state.dataAirLoop->AirLoopControlInfo(AirLoopNum).EconoActive) {
                 CompressorOn = HVAC::CompressorOp::Off;
@@ -7817,7 +7297,7 @@ namespace UnitarySystems {
         }
         if (this->OAMixerExists) {
             // the PTHP does one or the other, but why can't an OA Mixer exist with the AT Mixer?
-            MixedAir::SimOAMixer(state, blankStdString, this->OAMixerIndex);
+            MixedAir::SimOAMixer(state, this->OAMixerIndex);
         }
         if (this->m_FanExists && this->m_FanPlace == HVAC::FanPlace::BlowThru) {
             state.dataFans->fans(this->m_FanIndex)->simulate(state, FirstHVACIteration, state.dataUnitarySystems->FanSpeedRatio);
@@ -8031,8 +7511,8 @@ namespace UnitarySystems {
                 }
 
                 if (ZoneLoad < 0.0 && state.dataUnitarySystems->MoistureLoad <= 0.0 &&
-                    (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling &&
-                     state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag)) {
+                    (this->m_coolCoilType == HVAC::CoilType::CoolingDX &&
+                     state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag)) {
                     this->LoadSHR =
                         ZoneLoad / (ZoneLoad + state.dataUnitarySystems->MoistureLoad *
                                                    Psychrometrics::PsyHgAirFnWTdb(
@@ -8186,14 +7666,14 @@ namespace UnitarySystems {
             if (SpeedNumEMS > this->m_NumOfSpeedHeating) {
                 SpeedNumEMS = this->m_NumOfSpeedHeating;
                 useMaxedSpeed = true;
-                useMaxedSpeedCoilName = this->m_HeatingCoilName;
+                useMaxedSpeedCoilName = this->m_HeatCoilName;
             }
             this->m_HeatingSpeedNum = SpeedNumEMS;
         } else {
             if (SpeedNumEMS > this->m_NumOfSpeedCooling) {
                 SpeedNumEMS = this->m_NumOfSpeedCooling;
                 useMaxedSpeed = true;
-                useMaxedSpeedCoilName = this->m_CoolingCoilName;
+                useMaxedSpeedCoilName = this->m_CoolCoilName;
             }
             this->m_CoolingSpeedNum = SpeedNumEMS;
         }
@@ -8691,11 +8171,11 @@ namespace UnitarySystems {
                                                   HeatCoilLoad,
                                                   SupHeaterLoad,
                                                   CompressorONFlag);
-                    if (state.dataGlobal->DoCoilDirectSolutions && this->m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+                    if (state.dataGlobal->DoCoilDirectSolutions && this->m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                         this->FullOutput[SpeedNum] = SensOutputOn;
                     }
-                    if (this->m_HeatingCoilType_Num != HVAC::Coil_HeatingWaterToAirHPVSEquationFit &&
-                        (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater && !this->m_MultiSpeedHeatingCoil)) {
+                    if (this->m_heatCoilType != HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit &&
+                        (this->m_heatCoilType == HVAC::CoilType::HeatingWater && !this->m_MultiSpeedHeatingCoil)) {
                         this->m_HeatingSpeedRatio = 0.0;
                         this->m_HeatingSpeedNum = SpeedNum - 1;
                         if (this->m_HeatingSpeedNum == 0) {
@@ -8747,13 +8227,13 @@ namespace UnitarySystems {
                                                   SupHeaterLoad,
                                                   CompressorONFlag);
                     if (state.dataGlobal->DoCoilDirectSolutions &&
-                        (this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling ||
-                         (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && this->m_NumOfSpeedCooling > 1))) {
+                        (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                         (this->m_coolCoilType == HVAC::CoilType::CoolingDX && this->m_NumOfSpeedCooling > 1))) {
                         this->FullOutput[SpeedNum] = SensOutputOn;
                     }
                     // over specified logic? it has to be a water coil? what about other VS coil models?
-                    if ((this->m_CoolingCoilType_Num != HVAC::Coil_CoolingWaterToAirHPVSEquationFit) &&
-                        ((this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) &&
+                    if ((this->m_coolCoilType != HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) &&
+                        ((this->m_coolCoilType == HVAC::CoilType::CoolingWater || this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) &&
                          !this->m_DiscreteSpeedCoolingCoil)) {
                         this->m_CoolingSpeedRatio = 0.0;
                         this->m_CoolingSpeedNum = SpeedNum - 1;
@@ -8813,7 +8293,7 @@ namespace UnitarySystems {
                                               HeatCoilLoad,
                                               SupHeaterLoad,
                                               CompressorONFlag);
-                if (this->m_HeatingCoilType_Num != HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                if (this->m_heatCoilType != HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                     this->m_HeatingSpeedRatio = 0.0;
                     this->m_HeatingSpeedNum = SpeedNum - 1;
                     if (this->m_HeatingSpeedNum == 0) {
@@ -8865,7 +8345,7 @@ namespace UnitarySystems {
                                               SupHeaterLoad,
                                               CompressorONFlag);
 
-                if (this->m_CoolingCoilType_Num != HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
+                if (this->m_coolCoilType != HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
                     this->m_CoolingSpeedRatio = 0.0;
                     this->m_CoolingSpeedNum = SpeedNum - 1;
                     if (this->m_CoolingSpeedNum == 0) {
@@ -8933,10 +8413,10 @@ namespace UnitarySystems {
                     (state.dataUnitarySystems->CoolingLoad && ZoneLoad < SensOutputOff)) {
                     Real64 SensOutput;
                     Real64 LatOutput;
-                    if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling &&
-                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDX &&
+                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                         if (state.dataUnitarySystems->CoolingLoad && this->LoadSHR > 0.0) {
-                            int CoilInletNode = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].evapInletNodeIndex;
+                            int CoilInletNode = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].evapInletNodeIndex;
                             this->CoilSHR = 0.0;
                             Real64 LowSpeedCoilSen;
                             Real64 LowSpeedCoilLat;
@@ -9082,7 +8562,7 @@ namespace UnitarySystems {
                         }
                     }
                     if (state.dataGlobal->DoCoilDirectSolutions && state.dataUnitarySystems->CoolingLoad &&
-                        this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
+                        this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                         CoolPLR = (ZoneLoad - SensOutputOff) / (SensOutputOn - SensOutputOff);
                         HeatPLR = 0.0;
                         this->calcUnitarySystemToLoad(state,
@@ -9099,8 +8579,8 @@ namespace UnitarySystems {
                                                       CompressorONFlag);
                         PartLoadRatio = CoolPLR;
                     } else if (state.dataGlobal->DoCoilDirectSolutions && state.dataUnitarySystems->CoolingLoad &&
-                               this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && this->m_NumOfSpeedCooling == 1 &&
-                               state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+                               this->m_coolCoilType == HVAC::CoilType::CoolingDX && this->m_NumOfSpeedCooling == 1 &&
+                               state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                         HeatPLR = 0.0;
                         this->calcUnitarySystemToLoad(state,
                                                       AirLoopNum,
@@ -9129,7 +8609,7 @@ namespace UnitarySystems {
                                                       CompressorONFlag);
                         PartLoadRatio = CoolPLR;
                     } else if (state.dataGlobal->DoCoilDirectSolutions && state.dataUnitarySystems->CoolingLoad &&
-                               this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && this->m_NumOfSpeedCooling == 1) {
+                               this->m_coolCoilType == HVAC::CoilType::CoolingDX && this->m_NumOfSpeedCooling == 1) {
                         CoolPLR = (ZoneLoad - SensOutputOff) / (SensOutputOn - SensOutputOff);
                         HeatPLR = 0.0;
                         this->calcUnitarySystemToLoad(state,
@@ -9146,9 +8626,9 @@ namespace UnitarySystems {
                                                       CompressorONFlag);
                         PartLoadRatio = CoolPLR;
                     } else if (state.dataGlobal->DoCoilDirectSolutions && state.dataUnitarySystems->HeatingLoad &&
-                               (this->m_HeatingCoilType_Num == HVAC::CoilDX_HeatingEmpirical ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric ||
-                                this->m_HeatingCoilType_Num == HVAC::Coil_HeatingGasOrOtherFuel)) {
+                               (this->m_heatCoilType == HVAC::CoilType::HeatingDXSingleSpeed ||
+                                this->m_heatCoilType == HVAC::CoilType::HeatingElectric ||
+                                this->m_heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel)) {
                         CoolPLR = 0.0;
                         HeatPLR = (ZoneLoad - SensOutputOff) / (SensOutputOn - SensOutputOff);
                         this->calcUnitarySystemToLoad(state,
@@ -9165,7 +8645,7 @@ namespace UnitarySystems {
                                                       CompressorONFlag);
                         PartLoadRatio = HeatPLR;
                     } else if (state.dataGlobal->DoCoilDirectSolutions && state.dataUnitarySystems->HeatingLoad &&
-                               this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating) {
+                               this->m_coolCoilType == HVAC::CoilType::HeatingDXMultiSpeed) {
                         CoolPLR = 0.0;
                         if (this->m_HeatingSpeedNum == 1) {
                             this->m_HeatingCycRatio = (ZoneLoad - SensOutputOff) / (this->FullOutput[this->m_HeatingSpeedNum] - SensOutputOff);
@@ -9191,7 +8671,7 @@ namespace UnitarySystems {
                                                       CompressorONFlag);
                         PartLoadRatio = HeatPLR;
                     } else if (state.dataGlobal->DoCoilDirectSolutions && state.dataUnitarySystems->CoolingLoad &&
-                               this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && this->m_NumOfSpeedCooling > 1) {
+                               this->m_coolCoilType == HVAC::CoilType::CoolingDX && this->m_NumOfSpeedCooling > 1) {
                         HeatPLR = 0.0;
                         if (this->m_CoolingSpeedNum == 1) {
                             this->m_CoolingCycRatio = (ZoneLoad - SensOutputOff) / (this->FullOutput[this->m_CoolingSpeedNum] - SensOutputOff);
@@ -9635,13 +9115,13 @@ namespace UnitarySystems {
                                                       HeatCoilLoad,
                                                       SupHeaterLoad,
                                                       CompressorONFlag);
-                        if (state.dataGlobal->DoCoilDirectSolutions && this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                        if (state.dataGlobal->DoCoilDirectSolutions && this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
                             this->FullOutput[SpeedNum] = SensOutputOn;
                         }
                         // over specified logic? it has to be a water coil? what about other VS coil models?
-                        if ((this->m_CoolingCoilType_Num != HVAC::Coil_CoolingWaterToAirHPVSEquationFit) &&
-                            ((this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater ||
-                              this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) &&
+                        if ((this->m_coolCoilType != HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) &&
+                            ((this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                              this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) &&
                              !this->m_DiscreteSpeedCoolingCoil)) {
                             this->m_CoolingSpeedRatio = 0.0;
                             this->m_CoolingSpeedNum = SpeedNum - 1;
@@ -9944,10 +9424,9 @@ namespace UnitarySystems {
 
                 if (this->MaxHeatCoilFluidFlow == DataSizing::AutoSize) {
                     // IF water coil max water flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater) {
-                        WaterCoils::SimulateWaterCoilComponents(state, this->m_HeatingCoilName, FirstHVACIteration, this->m_HeatingCoilIndex);
-                        Real64 CoilMaxVolFlowRate =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_HeatingCoilName, errorsFound);
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingWater) {
+                        WaterCoils::SimulateWaterCoilComponents(state, this->m_HeatCoilNum, FirstHVACIteration);
+                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                             Real64 rho = state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum)
                                              .glycol->getDensity(state, Constant::CWInitConvTemp, routineName);
@@ -9955,14 +9434,14 @@ namespace UnitarySystems {
                         }
                     }
                     // IF steam coil max steam flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
-                    if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
+                    if (this->m_heatCoilType == HVAC::CoilType::HeatingSteam) {
                         SteamCoils::SimulateSteamCoilComponents(state,
-                                                                this->m_HeatingCoilName,
+                                                                this->m_HeatCoilName,
                                                                 FirstHVACIteration,
-                                                                this->m_HeatingCoilIndex,
+                                                                this->m_HeatCoilNum,
                                                                 1.0,
                                                                 QActual); // QCoilReq, simulate any load > 0 to get max capacity
-                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_HeatingCoilIndex, errorsFound);
+                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_HeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                             Real64 TempSteamIn = 100.0;
                             Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, routineName);
@@ -9976,29 +9455,26 @@ namespace UnitarySystems {
             }
             if (this->m_SuppCoilFluidInletNode > 0) {
                 if (this->m_MaxSuppCoilFluidFlow == DataSizing::AutoSize) {
-                    if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingWater) {
+                    if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingWater) {
                         // IF water coil max water flow rate is DataSizing::AutoSized, simulate once in order to mine max flow rate
-                        WaterCoils::SimulateWaterCoilComponents(state, this->m_SuppHeatCoilName, FirstHVACIteration, this->m_SuppHeatCoilIndex);
-                        Real64 CoilMaxVolFlowRate =
-                            WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_SuppHeatCoilName, errorsFound);
+                        WaterCoils::SimulateWaterCoilComponents(state, this->m_SuppHeatCoilNum, FirstHVACIteration);
+                        Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, this->m_SuppHeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
                             Real64 rho = state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum)
                                              .glycol->getDensity(state, Constant::CWInitConvTemp, routineName);
                             this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho;
                         }
-                    }
-                    if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+
+                    } else if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingSteam) {
                         SteamCoils::SimulateSteamCoilComponents(state,
                                                                 this->m_SuppHeatCoilName,
                                                                 FirstHVACIteration,
-                                                                this->m_SuppHeatCoilIndex,
+                                                                this->m_SuppHeatCoilNum,
                                                                 1.0,
                                                                 QActual); // QCoilReq, simulate any load > 0 to get max capacity
-                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_SuppHeatCoilIndex, errorsFound);
+                        Real64 CoilMaxVolFlowRate = SteamCoils::GetCoilMaxSteamFlowRate(state, this->m_SuppHeatCoilNum);
                         if (CoilMaxVolFlowRate != DataSizing::AutoSize) {
-                            Real64 TempSteamIn = 100.0;
-                            Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, routineName);
-                            this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * SteamDensity;
+                            this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, routineName);
                         }
                     }
                     PlantUtilities::InitComponentNodes(
@@ -11103,7 +10579,7 @@ namespace UnitarySystems {
             // the PTHP does one or the other, but why can't an OA Mixer exist with the AT Mixer?
             // use of a blank std::string is not great here, but I'm not ready to change this API at the moment, so passing a static blank string is
             // at least better than constructing a new string each time to call this function
-            MixedAir::SimOAMixer(state, blankStdString, this->OAMixerIndex);
+            MixedAir::SimOAMixer(state, this->OAMixerIndex);
         }
 
         if (this->m_FanExists && this->m_FanPlace == HVAC::FanPlace::BlowThru) {
@@ -11273,8 +10749,6 @@ namespace UnitarySystems {
         Real64 PartLoadFrac = 0.0;
         Real64 SpeedRatio = 0.0;
         Real64 CycRatio = 0.0;
-        std::string CompName = this->m_SuppHeatCoilName;
-        int CompIndex = this->m_SuppHeatCoilIndex;
         HVAC::FanOp fanOp = this->m_FanOpMode;
         Real64 QCoilActual = 0.0; // Heating coil operating capacity [W]
         int SpeedNum = 0;
@@ -11291,10 +10765,10 @@ namespace UnitarySystems {
         for (SpeedNum = 1; SpeedNum <= this->m_NumOfSpeedSuppHeating; ++SpeedNum) {
             this->m_SuppHeatingSpeedNum = SpeedNum;
             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                        CompName,
+                                                        this->m_SuppHeatCoilName,
                                                         FirstHVACIteration,
                                                         SuppHeatLoad,
-                                                        CompIndex,
+                                                        this->m_SuppHeatCoilNum,
                                                         QCoilActual,
                                                         SuppHeatingCoilFlag,
                                                         fanOp,
@@ -11314,9 +10788,8 @@ namespace UnitarySystems {
             if (this->m_SuppHeatingSpeedNum > 1.0) {
                 auto f = [&state, this, CycRatio, fanOp, SuppHeatLoad](Real64 const SpeedRatio) {
                     Real64 QActual;
-                    int CoilIndex = this->m_SuppHeatCoilIndex;
                     int SpeedNum = this->m_SuppHeatingSpeedNum;
-                    HeatingCoils::CalcMultiStageElectricHeatingCoil(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, QActual, true);
+                    HeatingCoils::CalcMultiStageElectricHeatingCoil(state, this->m_SuppHeatCoilNum, SpeedRatio, CycRatio, SpeedNum, fanOp, QActual, true);
                     return SuppHeatLoad - QActual;
                 };
 
@@ -11330,9 +10803,8 @@ namespace UnitarySystems {
                 this->m_SuppHeatingSpeedRatio = SpeedRatio;
                 auto f = [&state, this, SpeedRatio, fanOp, SuppHeatLoad](Real64 const CycRatio) {
                     Real64 QActual;
-                    int CoilIndex = this->m_SuppHeatCoilIndex;
                     int SpeedNum = this->m_SuppHeatingSpeedNum;
-                    HeatingCoils::CalcMultiStageElectricHeatingCoil(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, QActual, true);
+                    HeatingCoils::CalcMultiStageElectricHeatingCoil(state, this->m_SuppHeatCoilNum, SpeedRatio, CycRatio, SpeedNum, fanOp, QActual, true);
                     return SuppHeatLoad - QActual;
                 };
 
@@ -11445,8 +10917,6 @@ namespace UnitarySystems {
         Real64 OutdoorPressure;    // Outdoor barometric pressure at condenser (Pa)
 
         // Simulate the coil component
-        std::string CompName = this->m_CoolingCoilName;
-        int CompIndex = this->m_CoolingCoilIndex;
         Real64 CoilPLR = 1.0;
         if (this->m_CondenserNodeNum != 0) {
             OutdoorPressure = state.dataLoopNodes->Node(this->m_CondenserNodeNum).Press;
@@ -11460,20 +10930,13 @@ namespace UnitarySystems {
             OutsideDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
         }
 
-        switch (this->m_CoolingCoilType_Num) {
-        case HVAC::CoilDX_CoolingSingleSpeed: { // Coil:Cooling:DX:SingleSpeed
-            DXCoils::SimDXCoil(state,
-                               blankString,
-                               CompressorOn,
-                               FirstHVACIteration,
-                               CompIndex,
-                               this->m_FanOpMode,
-                               PartLoadRatio,
-                               OnOffAirFlowRatio,
-                               CoilCoolHeatRat);
+        switch (this->m_coolCoilType) {
+        case HVAC::CoilType::CoolingDXSingleSpeed: { // Coil:Cooling:DX:SingleSpeed
+            DXCoils::SimDXCoil(
+                state, this->m_CoolCoilNum, CompressorOn, FirstHVACIteration, this->m_FanOpMode, PartLoadRatio, OnOffAirFlowRatio, CoilCoolHeatRat);
             this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? PartLoadRatio : 0.0;
         } break;
-        case HVAC::CoilDX_Cooling: { // CoilCoolingDX
+        case HVAC::CoilType::CoolingDX: { // CoilCoolingDX
             bool const singleMode = (this->m_SingleMode == 1);
             CoilPLR = 0.0;
             if (this->m_ControlType == UnitarySysCtrlType::Setpoint) {
@@ -11503,13 +10966,13 @@ namespace UnitarySystems {
             }
 
             HVAC::CoilMode coilMode = HVAC::CoilMode::Normal;
-            if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+            if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                 coilMode = HVAC::CoilMode::SubcoolReheat;
             } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) {
                 coilMode = HVAC::CoilMode::Enhanced;
             }
 
-            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                 state, coilMode, this->m_CoolingSpeedNum, CoilPLR, this->m_FanOpMode, singleMode, this->CoilSHR);
 
             if (this->m_CoolingSpeedNum > 1) {
@@ -11526,46 +10989,48 @@ namespace UnitarySystems {
                 this->m_CoolingSpeedRatio = 0.0;
             }
         } break;
-        case HVAC::CoilDX_CoolingHXAssisted:
-        case HVAC::CoilWater_CoolingHXAssisted: {
-            if (this->m_CoolingCoilType_Num == HVAC::CoilWater_CoolingHXAssisted) {
+
+        case HVAC::CoilType::CoolingDXHXAssisted:
+        case HVAC::CoilType::CoolingWaterHXAssisted: {
+          if (this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
                 mdot =
                     min(state.dataLoopNodes->Node(this->CoolCoilFluidOutletNodeNum).MassFlowRateMaxAvail, this->MaxCoolCoilFluidFlow * PartLoadRatio);
                 state.dataLoopNodes->Node(this->CoolCoilFluidInletNode).MassFlowRate = mdot;
             }
-            HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                blankString,
-                                                                FirstHVACIteration,
-                                                                CompressorOn,
-                                                                PartLoadRatio,
-                                                                CompIndex,
-                                                                this->m_FanOpMode,
-                                                                HXUnitOn,
-                                                                OnOffAirFlowRatio,
-                                                                state.dataUnitarySystems->economizerFlag,
-                                                                _,
-                                                                this->m_DehumidificationMode,
-                                                                0.0); // this->CoilSHR);
-            if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
+            HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                   this->m_CoolCoilName,
+                                                   FirstHVACIteration,
+                                                   CompressorOn,
+                                                   PartLoadRatio,
+                                                   this->m_CoolCoilNum,
+                                                   this->m_FanOpMode,
+                                                   HXUnitOn,
+                                                   OnOffAirFlowRatio,
+                                                   state.dataUnitarySystems->economizerFlag,
+                                                   _,
+                                                   this->m_DehumidificationMode,
+                                                   0.0); // this->CoilSHR);
+            if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
                 this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? PartLoadRatio : 0.0;
             }
         } break;
-        case HVAC::CoilDX_CoolingTwoSpeed: { // Coil:Cooling:DX:TwoSpeed
+        case HVAC::CoilType::CoolingDXTwoSpeed: { // Coil:Cooling:DX:TwoSpeed
             // formerly (v3 and beyond)COIL:DX:MULTISPEED:COOLINGEMPIRICAL
-            DXCoils::SimDXCoilMultiSpeed(state, blankString, this->m_CoolingSpeedRatio, this->m_CoolingCycRatio, CompIndex);
+            DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilName, this->m_CoolingSpeedRatio, this->m_CoolingCycRatio, this->m_CoolCoilNum);
             if (this->m_CoolingSpeedRatio > 0.0) {
                 this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? this->m_CoolingSpeedRatio : 0.0;
             } else {
                 this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? this->m_CoolingCycRatio : 0.0;
             }
         } break;
-        case HVAC::CoilDX_MultiSpeedCooling: { // Coil:Cooling:DX:Multispeed
+          
+        case HVAC::CoilType::CoolingDXMultiSpeed: { // Coil:Cooling:DX:Multispeed
             if (OutsideDryBulbTemp > this->m_MinOATCompressorCooling) {
                 DXCoils::SimDXCoilMultiSpeed(state,
-                                             CompName,
+                                             this->m_CoolCoilName,
                                              this->m_CoolingSpeedRatio,
                                              this->m_CoolingCycRatio,
-                                             CompIndex,
+                                             this->m_CoolCoilNum,
                                              this->m_CoolingSpeedNum,
                                              this->m_FanOpMode,
                                              CompressorOn,
@@ -11580,24 +11045,26 @@ namespace UnitarySystems {
                     this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? this->m_CoolingCycRatio : 0.0;
                 }
             } else {
-                DXCoils::SimDXCoilMultiSpeed(state, CompName, 0.0, 0.0, CompIndex, this->m_CoolingSpeedNum, this->m_FanOpMode, CompressorOn);
+                DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilName, 0.0, 0.0, this->m_CoolCoilNum, this->m_CoolingSpeedNum, this->m_FanOpMode, CompressorOn);
                 this->m_CoolCompPartLoadRatio = 0.0;
             }
         } break;
-        case HVAC::CoilDX_CoolingTwoStageWHumControl: {
+          
+        case HVAC::CoilType::CoolingDXTwoStageWHumControl: {
             // formerly (v3 and beyond) COIL:DX:MULTIMODE:COOLINGEMPIRICAL
             DXCoils::SimDXCoilMultiMode(
-                state, CompName, CompressorOn, FirstHVACIteration, PartLoadRatio, this->m_DehumidificationMode, CompIndex, this->m_FanOpMode);
+                state, this->m_CoolCoilName, CompressorOn, FirstHVACIteration, PartLoadRatio, this->m_DehumidificationMode, this->m_CoolCoilNum, this->m_FanOpMode);
             this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? PartLoadRatio : 0.0;
         } break;
-        case HVAC::Coil_UserDefined: {
+          
+        case HVAC::CoilType::UserDefined: {
             bool HeatingActive = false; // set to arbitrary value on entry to function
             bool CoolingActive = false; // set to arbitrary value on entry to function
 
-            UserDefinedComponents::SimCoilUserDefined(state, CompName, CompIndex, AirLoopNum, HeatingActive, CoolingActive);
+            UserDefinedComponents::SimCoilUserDefined(state, this->m_CoolCoilName, this->m_CoolCoilNum, AirLoopNum, HeatingActive, CoolingActive);
         } break;
-        case HVAC::Coil_CoolingWater:
-        case HVAC::Coil_CoolingWaterDetailed: {
+        case HVAC::CoilType::CoolingWater:
+        case HVAC::CoilType::CoolingWaterDetailed: {
             if (this->CoolCoilWaterFlowRatio == 0.0) {
                 mdot = this->MaxCoolCoilFluidFlow * PartLoadRatio;
             } else {
@@ -11605,18 +11072,18 @@ namespace UnitarySystems {
             }
             state.dataLoopNodes->Node(this->CoolCoilFluidInletNode).MassFlowRate = mdot;
             WaterCoils::SimulateWaterCoilComponents(
-                state, CompName, FirstHVACIteration, this->m_CoolingCoilIndex, QActual, this->m_FanOpMode, PartLoadRatio);
+                state, this->m_CoolCoilName, FirstHVACIteration, this->m_CoolCoilNum, QActual, this->m_FanOpMode, PartLoadRatio);
         } break;
-        case HVAC::Coil_CoolingAirToAirVariableSpeed:
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::CoolingDXVariableSpeed:
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
             if (this->m_CoolingSpeedNum > 1) {
                 CoilPLR = 1.0;
             } else {
                 CoilPLR = PartLoadRatio;
             }
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      CompName,
-                                                      CompIndex,
+                                                      this->m_CoolCoilName,
+                                                      this->m_CoolCoilNum,
                                                       this->m_FanOpMode,
                                                       CompressorOn,
                                                       CoilPLR,
@@ -11631,11 +11098,10 @@ namespace UnitarySystems {
                 this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? PartLoadRatio : 0.0;
             }
         } break;
-        case HVAC::Coil_CoolingWaterToAirHPSimple: {
+        case HVAC::CoilType::CoolingWAHPSimple: {
 
             WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                            blankString,
-                                                            this->m_CoolingCoilIndex,
+                                                            this->m_CoolCoilNum,
                                                             this->m_CoolingCoilSensDemand,
                                                             this->m_CoolingCoilLatentDemand,
                                                             this->m_FanOpMode,
@@ -11644,11 +11110,10 @@ namespace UnitarySystems {
                                                             FirstHVACIteration);
             this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? PartLoadRatio : 0.0;
         } break;
-        case HVAC::Coil_CoolingWaterToAirHP: {
+        case HVAC::CoilType::CoolingWAHP: {
 
             WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                blankString,
-                                                this->m_CoolingCoilIndex,
+                                                this->m_CoolCoilNum,
                                                 this->MaxCoolAirMassFlow,
                                                 this->m_FanOpMode,
                                                 FirstHVACIteration,
@@ -11660,8 +11125,8 @@ namespace UnitarySystems {
 
             this->m_CoolCompPartLoadRatio = (CompressorOn == HVAC::CompressorOp::On) ? PartLoadRatio : 0.0;
         } break;
-        case HVAC::CoilDX_PackagedThermalStorageCooling: {
-            PackagedThermalStorageCoil::SimTESCoil(state, CompName, this->m_CoolingCoilIndex, this->m_FanOpMode, this->m_TESOpMode, PartLoadRatio);
+        case HVAC::CoilType::CoolingDXPackagedThermalStorage: {
+            PackagedThermalStorageCoil::SimTESCoil(state, this->m_CoolCoilName, this->m_CoolCoilNum, this->m_FanOpMode, this->m_TESOpMode, PartLoadRatio);
         } break;
         default:
             break;
@@ -11693,7 +11158,6 @@ namespace UnitarySystems {
         Real64 QActual;            // actual output of coil (W)
         Real64 OutdoorPressure;    // Outdoor barometric pressure at condenser (Pa)
 
-        std::string CompName = this->m_HeatingCoilName;
         Real64 dummy = 0.0;
         Real64 HeatPLR = 1.0;
         if (this->m_CondenserNodeNum != 0) {
@@ -11708,35 +11172,34 @@ namespace UnitarySystems {
             OutsideDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
         }
 
-        switch (this->m_HeatingCoilType_Num) {
-        case HVAC::CoilDX_HeatingEmpirical: { // COIL:HEATING:DX:SINGLESPEED
+        switch (this->m_heatCoilType) {
+        case HVAC::CoilType::HeatingDXSingleSpeed: { // COIL:HEATING:DX:SINGLESPEED
             DXCoils::SimDXCoil(
-                state, CompName, CompressorOn, FirstHVACIteration, this->m_HeatingCoilIndex, this->m_FanOpMode, PartLoadRatio, OnOffAirFlowRatio);
+                state, this->m_HeatCoilNum, CompressorOn, FirstHVACIteration, this->m_FanOpMode, PartLoadRatio, OnOffAirFlowRatio);
             this->m_HeatCompPartLoadRatio = PartLoadRatio * double(CompressorOn);
         } break;
-        case HVAC::Coil_UserDefined: {
+        case HVAC::CoilType::UserDefined: {
             bool HeatingActive = false; // set to arbitrary value on entry to function
             bool CoolingActive = true;  // set to arbitrary value on entry to function
-            UserDefinedComponents::SimCoilUserDefined(state, CompName, this->m_HeatingCoilIndex, AirLoopNum, HeatingActive, CoolingActive);
+            UserDefinedComponents::SimCoilUserDefined(state, this->m_HeatCoilName, this->m_HeatCoilNum, AirLoopNum, HeatingActive, CoolingActive);
         } break;
-        case HVAC::Coil_HeatingGasOrOtherFuel:
-        case HVAC::Coil_HeatingElectric: {
+        case HVAC::CoilType::HeatingGasOrOtherFuel:
+        case HVAC::CoilType::HeatingElectric: {
             HeatCoilLoad = PartLoadRatio * m_DesignHeatingCapacity;
             HeatingCoils::SimulateHeatingCoilComponents(
-                state, CompName, FirstHVACIteration, HeatCoilLoad, this->m_HeatingCoilIndex, _, false, this->m_FanOpMode, PartLoadRatio);
+                state, this->m_HeatCoilNum, FirstHVACIteration, HeatCoilLoad, _, false, this->m_FanOpMode, PartLoadRatio);
         } break;
-        case HVAC::Coil_HeatingDesuperheater: {
+        case HVAC::CoilType::HeatingDesuperheater: {
             HeatingCoils::SimulateHeatingCoilComponents(
-                state, CompName, FirstHVACIteration, HeatCoilLoad, this->m_HeatingCoilIndex, _, false, this->m_FanOpMode, PartLoadRatio);
+                state, this->m_HeatCoilNum, FirstHVACIteration, HeatCoilLoad, _, false, this->m_FanOpMode, PartLoadRatio);
 
         } break;
-        case HVAC::CoilDX_MultiSpeedHeating: {
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
             if (OutsideDryBulbTemp > this->m_MinOATCompressorHeating) {
                 DXCoils::SimDXCoilMultiSpeed(state,
-                                             CompName,
+                                             this->m_HeatCoilNum,
                                              this->m_HeatingSpeedRatio,
                                              this->m_HeatingCycRatio,
-                                             this->m_HeatingCoilIndex,
                                              this->m_HeatingSpeedNum,
                                              this->m_FanOpMode,
                                              CompressorOn,
@@ -11744,14 +11207,14 @@ namespace UnitarySystems {
                 this->m_HeatCompPartLoadRatio = PartLoadRatio * double(CompressorOn);
             } else {
                 DXCoils::SimDXCoilMultiSpeed(
-                    state, CompName, 0.0, 0.0, this->m_HeatingCoilIndex, this->m_HeatingSpeedNum, this->m_FanOpMode, CompressorOn);
+                    state, this->m_HeatCoilNum, 0.0, 0.0, this->m_HeatingSpeedNum, this->m_FanOpMode, CompressorOn);
                 this->m_HeatCompPartLoadRatio = 0.0;
             }
         } break;
-        case HVAC::Coil_HeatingElectric_MultiStage:
-        case HVAC::Coil_HeatingGas_MultiStage: {
+        case HVAC::CoilType::HeatingElectricMultiStage:
+        case HVAC::CoilType::HeatingGasMultiStage: {
             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                        CompName,
+                                                        this->m_HeatCoilName,
                                                         FirstHVACIteration,
                                                         _,
                                                         0,
@@ -11764,7 +11227,7 @@ namespace UnitarySystems {
             // This doesn't look right when it was at higher speed
             // this->m_HeatingCycRatio = PartLoadRatio;
         } break;
-        case HVAC::Coil_HeatingWater: {
+        case HVAC::CoilType::HeatingWater: {
             if (this->HeatCoilWaterFlowRatio == 0.0) {
                 mdot = this->MaxHeatCoilFluidFlow * PartLoadRatio;
             } else {
@@ -11772,9 +11235,9 @@ namespace UnitarySystems {
             }
             state.dataLoopNodes->Node(this->HeatCoilFluidInletNode).MassFlowRate = mdot;
             WaterCoils::SimulateWaterCoilComponents(
-                state, CompName, FirstHVACIteration, this->m_HeatingCoilIndex, QActual, this->m_FanOpMode, PartLoadRatio);
+                state, this->m_HeatCoilName, FirstHVACIteration, this->m_HeatCoilNum, QActual, this->m_FanOpMode, PartLoadRatio);
         } break;
-        case HVAC::Coil_HeatingSteam: {
+        case HVAC::CoilType::HeatingSteam: {
             // this same CALL is made in the steam coil calc routine
             mdot = min(state.dataLoopNodes->Node(this->HeatCoilFluidOutletNodeNum).MassFlowRateMaxAvail, this->MaxHeatCoilFluidFlow * PartLoadRatio);
             if (this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP || this->m_sysType == SysType::PackagedWSHP) {
@@ -11785,16 +11248,16 @@ namespace UnitarySystems {
                 state.dataLoopNodes->Node(this->HeatCoilFluidInletNode).MassFlowRate = mdot;
             }
             SteamCoils::SimulateSteamCoilComponents(state,
-                                                    CompName,
+                                                    this->m_HeatCoilName,
                                                     FirstHVACIteration,
-                                                    this->m_HeatingCoilIndex,
+                                                    this->m_HeatCoilNum,
                                                     this->m_DesignHeatingCapacity * PartLoadRatio,
                                                     _,
                                                     this->m_FanOpMode,
                                                     PartLoadRatio);
         } break;
-        case HVAC::Coil_HeatingAirToAirVariableSpeed:
-        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::HeatingDXVariableSpeed:
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
             if (this->m_HeatingSpeedNum > 1) {
                 HeatPLR = 1.0;
                 if (this->m_sysType == SysType::PackagedAC || this->m_sysType == SysType::PackagedHP || this->m_sysType == SysType::PackagedWSHP) {
@@ -11805,8 +11268,7 @@ namespace UnitarySystems {
             }
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      CompName,
-                                                      this->m_HeatingCoilIndex,
+                                                      this->m_HeatCoilNum,
                                                       this->m_FanOpMode,
                                                       CompressorOn,
                                                       HeatPLR,
@@ -11821,11 +11283,10 @@ namespace UnitarySystems {
                 this->m_HeatCompPartLoadRatio = PartLoadRatio * double(CompressorOn);
             }
         } break;
-        case HVAC::Coil_HeatingWaterToAirHPSimple: {
+        case HVAC::CoilType::HeatingWAHPSimple: {
 
             WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                            blankString,
-                                                            this->m_HeatingCoilIndex,
+                                                            this->m_HeatCoilNum,
                                                             this->m_HeatingCoilSensDemand,
                                                             dummy,
                                                             this->m_FanOpMode,
@@ -11834,11 +11295,10 @@ namespace UnitarySystems {
                                                             FirstHVACIteration);
             this->m_HeatCompPartLoadRatio = PartLoadRatio * double(CompressorOn);
         } break;
-        case HVAC::Coil_HeatingWaterToAirHP: {
+        case HVAC::CoilType::HeatingWAHP: {
 
             WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                blankString,
-                                                this->m_HeatingCoilIndex,
+                                                this->m_HeatCoilNum,
                                                 this->MaxHeatAirMassFlow,
                                                 this->m_FanOpMode,
                                                 FirstHVACIteration,
@@ -11851,7 +11311,7 @@ namespace UnitarySystems {
         } break;
         default: {
             ShowFatalError(
-                state, format("CalcUnitaryHeatingSystem: Invalid Unitary System coil type = {}", HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num)));
+                state, format("CalcUnitaryHeatingSystem: Invalid Unitary System coil type = {}", HVAC::coilTypeNames[(int)this->m_heatCoilType]));
         } break;
         }
 
@@ -11886,7 +11346,6 @@ namespace UnitarySystems {
         Par.resize(5);
         // work is needed to figure out how to adjust other coil types if outlet temp exceeds maximum
         // this works for gas and electric heating coils
-        std::string CompName = this->m_SuppHeatCoilName;
         if (state.dataEnvrn->OutDryBulbTemp <= this->m_MaxOATSuppHeat ||
             (state.dataUnitarySystems->MoistureLoad < 0.0 && this->m_CoolingPartLoadFrac > 0.0)) {
             SuppHeatCoilLoad = SuppCoilLoad;
@@ -11896,17 +11355,17 @@ namespace UnitarySystems {
         } else {
             SuppHeatCoilLoad = 0.0;
         }
-        switch (this->m_SuppHeatCoilType_Num) {
-        case HVAC::Coil_HeatingGasOrOtherFuel:
-        case HVAC::Coil_HeatingElectric:
-        case HVAC::Coil_HeatingElectric_MultiStage: {
+        switch (this->m_SuppHeatCoilType) {
+        case HVAC::CoilType::HeatingGasOrOtherFuel:
+        case HVAC::CoilType::HeatingElectric:
+        case HVAC::CoilType::HeatingElectricMultiStage: {
             switch (this->m_ControlType) {
             case UnitarySysCtrlType::Setpoint: {
                 HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                            CompName,
+                                                            this->m_SuppHeatCoilName,
                                                             FirstHVACIteration,
                                                             SuppHeatCoilLoad,
-                                                            this->m_SuppHeatCoilIndex,
+                                                            this->m_SuppHeatCoilNum,
                                                             _,
                                                             true,
                                                             this->m_FanOpMode,
@@ -11924,15 +11383,15 @@ namespace UnitarySystems {
                         this->m_SuppHeatPartLoadFrac = 0.0;
                     }
                 } else {
-                    if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage) {
+                    if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectricMultiStage) {
                         this->calcMultiStageSuppCoilStageByLoad(state, SuppHeatCoilLoad, FirstHVACIteration);
                     }
                 }
                 HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                            CompName,
+                                                            this->m_SuppHeatCoilName,
                                                             FirstHVACIteration,
                                                             SuppHeatCoilLoad,
-                                                            this->m_SuppHeatCoilIndex,
+                                                            this->m_SuppHeatCoilNum,
                                                             _,
                                                             true,
                                                             this->m_FanOpMode,
@@ -11942,18 +11401,18 @@ namespace UnitarySystems {
             } break;
             }
         } break;
-        case HVAC::Coil_HeatingDesuperheater: {
+        case HVAC::CoilType::HeatingDesuperheater: {
             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                        CompName,
+                                                        this->m_SuppHeatCoilName,
                                                         FirstHVACIteration,
                                                         SuppHeatCoilLoad,
-                                                        this->m_SuppHeatCoilIndex,
+                                                        this->m_SuppHeatCoilNum,
                                                         _,
                                                         true,
                                                         this->m_FanOpMode,
                                                         this->m_SuppHeatPartLoadFrac);
         } break;
-        case HVAC::Coil_HeatingWater: {
+        case HVAC::CoilType::HeatingWater: {
             // see if HW coil has enough capacity to meet the load
             if (SuppHeatCoilLoad > 0.0) {
                 mdot = min(state.dataLoopNodes->Node(this->m_SuppCoilFluidOutletNodeNum).MassFlowRateMaxAvail, this->m_MaxSuppCoilFluidFlow);
@@ -11965,7 +11424,7 @@ namespace UnitarySystems {
             WaterCoils::SimulateWaterCoilComponents(state,
                                                     this->m_SuppHeatCoilName,
                                                     FirstHVACIteration,
-                                                    this->m_SuppHeatCoilIndex,
+                                                    this->m_SuppHeatCoilNum,
                                                     QActual,
                                                     this->m_FanOpMode,
                                                     this->m_SuppHeatPartLoadFrac);
@@ -11975,7 +11434,7 @@ namespace UnitarySystems {
                                       this->m_MaxSuppCoilFluidFlow * PartLoadFrac);
                     state.dataLoopNodes->Node(this->m_SuppCoilFluidInletNode).MassFlowRate = mdot;
                     WaterCoils::SimulateWaterCoilComponents(
-                        state, this->m_SuppHeatCoilName, FirstHVACIteration, this->m_SuppHeatCoilIndex, 0.0, this->m_FanOpMode, PartLoadFrac);
+                        state, this->m_SuppHeatCoilName, FirstHVACIteration, this->m_SuppHeatCoilNum, 0.0, this->m_FanOpMode, PartLoadFrac);
                     return SuppHeatCoilLoad;
                 };
                 int SolFla; // Flag of solver, num iterations if >0, else error index
@@ -11985,12 +11444,12 @@ namespace UnitarySystems {
                 this->m_SuppHeatPartLoadFrac = (SuppHeatCoilLoad > 0.0) ? 1.0 : 0.0;
             }
         } break;
-        case HVAC::Coil_HeatingSteam: {
+        case HVAC::CoilType::HeatingSteam: {
             mdot = min(state.dataLoopNodes->Node(this->m_SuppCoilFluidOutletNodeNum).MassFlowRateMaxAvail,
                        this->m_MaxSuppCoilFluidFlow * this->m_SuppHeatPartLoadFrac);
             state.dataLoopNodes->Node(this->m_SuppCoilFluidInletNode).MassFlowRate = mdot;
             SteamCoils::SimulateSteamCoilComponents(
-                state, CompName, FirstHVACIteration, this->m_SuppHeatCoilIndex, SuppHeatCoilLoad, _, this->m_FanOpMode, this->m_SuppHeatPartLoadFrac);
+                state, this->m_SuppHeatCoilName, FirstHVACIteration, this->m_SuppHeatCoilNum, SuppHeatCoilLoad, _, this->m_FanOpMode, this->m_SuppHeatPartLoadFrac);
         } break;
         default:
             break;
@@ -12080,7 +11539,6 @@ namespace UnitarySystems {
         int InletNode = this->CoolCoilInletNodeNum;
         Real64 DesOutTemp = this->m_DesiredOutletTemp;
         Real64 DesOutHumRat = this->m_DesiredOutletHumRat;
-        int CoilType_Num = this->m_CoolingCoilType_Num;
         Real64 LoopDXCoilMaxRTFSave = 0.0;
         if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP &&
             this->m_sysType != SysType::PackagedWSHP) {
@@ -12088,7 +11546,6 @@ namespace UnitarySystems {
             state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF = 0.0;
         }
 
-        std::string CompName = this->m_CoolingCoilName;
         HVAC::FanOp fanOp = this->m_FanOpMode;
         Real64 SpeedRatio = 0.0;
         Real64 CycRatio = 0.0;
@@ -12114,14 +11571,14 @@ namespace UnitarySystems {
 
         // Check the dehumidification control type. IF it's multimode, turn off the HX to find the sensible PLR. Then check to
         // see if the humidity load is met without the use of the HX. Always run the HX for the other modes.
-        if (this->m_DehumidControlType_Num != DehumCtrlType::Multimode && this->m_CoolingCoilType_Num != HVAC::CoilDX_Cooling) {
+        if (this->m_DehumidControlType_Num != DehumCtrlType::Multimode && this->m_coolCoilType != HVAC::CoilType::CoolingDX) {
             HXUnitOn = true;
         } else {
             HXUnitOn = false;
         }
 
         // IF there is a fault of coil SAT Sensor
-        if (this->m_FaultyCoilSATFlag) {
+        if (this->m_FaultyCoilSATIndex > 0) {
             // calculate the sensor offset using fault information
             int FaultIndex = this->m_FaultyCoilSATIndex;
             this->m_FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
@@ -12130,7 +11587,7 @@ namespace UnitarySystems {
         }
 
         // IF UnitarySystem is scheduled on and there is flow
-        if ((this->m_sysAvailSched->getCurrentVal() > 0.0) && this->m_coolingCoilAvailSched->getCurrentVal() > 0.0 &&
+        if ((this->m_sysAvailSched->getCurrentVal() > 0.0) && this->m_coolCoilAvailSched->getCurrentVal() > 0.0 &&
             (state.dataLoopNodes->Node(InletNode).MassFlowRate > HVAC::SmallAirVolFlow)) {
 
             bool SensibleLoad = false;
@@ -12185,7 +11642,7 @@ namespace UnitarySystems {
                 }
 
                 WaterCoils::SimulateWaterCoilComponents(
-                    state, CompName, FirstHVACIteration, this->m_CoolingCoilIndex, _, this->m_FanOpMode, PartLoadFrac);
+                    state, this->m_CoolCoilName, FirstHVACIteration, this->m_CoolCoilNum, _, this->m_FanOpMode, PartLoadFrac);
                 SensibleLoad = false; // fall through remaining checks
                 LatentLoad = false;
             } else if (this->m_TemperatureOffsetControlActive) {
@@ -12212,7 +11669,8 @@ namespace UnitarySystems {
                 PartLoadFrac = 0.0;
                 compressorOp = HVAC::CompressorOp::Off;
 
-                if (this->m_EMSOverrideCoilSpeedNumOn && (CoilType_Num == HVAC::CoilDX_MultiSpeedCooling || CoilType_Num == HVAC::CoilDX_Cooling)) {
+                if (this->m_EMSOverrideCoilSpeedNumOn && (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                                                          this->m_coolCoilType == HVAC::CoilType::CoolingDX)) {
                     this->m_CoolingSpeedNum = ceil(this->m_EMSOverrideCoilSpeedNumValue);
                     this->m_SpeedNum = this->m_CoolingSpeedNum;
                     bool useMaxedSpeed = false;
@@ -12221,13 +11679,13 @@ namespace UnitarySystems {
                         this->m_SpeedNum = this->m_NumOfSpeedCooling;
                         useMaxedSpeed = true;
                         if (this->m_CoilSpeedErrIdx == 0) {
-                            ShowWarningMessage(state, format("Wrong coil speed EMS override value, for unit=\"{}", this->m_CoolingCoilName));
+                            ShowWarningMessage(state, format("Wrong coil speed EMS override value, for unit=\"{}", this->m_CoolCoilName));
                             ShowContinueError(state,
                                               "  Exceeding maximum coil speed level. Speed level is set to the maximum coil speed level allowed.");
                         }
                         ShowRecurringWarningErrorAtEnd(
                             state,
-                            "Wrong coil speed EMS override value, for unit=\"" + this->m_CoolingCoilName +
+                            "Wrong coil speed EMS override value, for unit=\"" + this->m_CoolCoilName +
                                 "\". Exceeding maximum coil speed level. Speed level is set to the maximum coil speed level allowed.",
                             this->m_CoilSpeedErrIdx,
                             this->m_EMSOverrideCoilSpeedNumValue,
@@ -12241,11 +11699,11 @@ namespace UnitarySystems {
                         this->m_CoolingSpeedNum = 0;
                         this->m_SpeedNum = 0;
                         if (this->m_CoilSpeedErrIdx == 0) {
-                            ShowWarningMessage(state, format("Wrong coil speed EMS override value, for unit=\"{}", this->m_CoolingCoilName));
+                            ShowWarningMessage(state, format("Wrong coil speed EMS override value, for unit=\"{}", this->m_CoolCoilName));
                             ShowContinueError(state, "  Input speed value is below zero. Speed level is set to zero.");
                         }
                         ShowRecurringWarningErrorAtEnd(state,
-                                                       "Wrong coil speed EMS override value, for unit=\"" + this->m_CoolingCoilName +
+                                                       "Wrong coil speed EMS override value, for unit=\"" + this->m_CoolCoilName +
                                                            "\". Input speed value is below zero. Speed level is set to zero.",
                                                        this->m_CoilSpeedErrIdx,
                                                        this->m_EMSOverrideCoilSpeedNumValue,
@@ -12275,7 +11733,7 @@ namespace UnitarySystems {
                         PartLoadFrac = this->m_CoolingSpeedRatio;
                     }
                     this->m_CoolCompPartLoadRatio = PartLoadFrac;
-                    if (CoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
                         this->simMultiSpeedCoils(state,
                                                  AirLoopNum,
                                                  FirstHVACIteration,
@@ -12283,7 +11741,7 @@ namespace UnitarySystems {
                                                  SensibleLoad,
                                                  LatentLoad,
                                                  PartLoadFrac,
-                                                 CoolingCoil,
+                                                 WhichCoil::Cool,
                                                  this->m_SpeedNum);
                         OutletTemp = state.dataLoopNodes->Node(OutletNode).Temp;
                         int SpeedNum = 0;
@@ -12292,87 +11750,88 @@ namespace UnitarySystems {
                         }
                     } else {
                         HVAC::CoilMode coilMode = HVAC::CoilMode::Normal;
-                        if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+                        if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                             coilMode = HVAC::CoilMode::SubcoolReheat;
                         } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) {
                             coilMode = HVAC::CoilMode::Enhanced;
                         }
                         bool const singleMode = (this->m_SingleMode == 1);
-                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                             state, coilMode, this->m_CoolingSpeedNum, PartLoadFrac, this->m_FanOpMode, singleMode);
                     }
 
-                } else if (CoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) { // COIL:DX:COOLINGBYPASSFACTOREMPIRICAL
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) { // COIL:DX:COOLINGBYPASSFACTOREMPIRICAL
                     this->m_CompPartLoadRatio = PartLoadFrac;
 
-                    DXCoils::SimDXCoil(state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, this->m_CoolingCoilIndex, fanOp, PartLoadFrac);
+                    DXCoils::SimDXCoil(state, this->m_CoolCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, fanOp, PartLoadFrac);
 
-                } else if ((CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) ||
-                           (CoilType_Num == HVAC::CoilWater_CoolingHXAssisted)) { // CoilSystem:Cooling:DX:HeatExchangerAssisted
+                } else if ((this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) ||
+                           (this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted)) { // CoilSystem:Cooling:DX:HeatExchangerAssisted
 
                     if (this->CoolCoilFluidInletNode > 0) state.dataLoopNodes->Node(this->CoolCoilFluidInletNode).MassFlowRate = 0.0;
 
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                        CompName,
-                                                                        FirstHVACIteration,
-                                                                        HVAC::CompressorOp::On,
-                                                                        PartLoadFrac,
-                                                                        this->m_CoolingCoilIndex,
-                                                                        fanOp,
-                                                                        HXUnitOn,
-                                                                        _,
-                                                                        state.dataUnitarySystems->economizerFlag,
-                                                                        _,
-                                                                        this->m_DehumidificationMode,
-                                                                        0.0); // this->CoilSHR);
-                    if (CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) this->m_CompPartLoadRatio = PartLoadFrac;
-                } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
-
-                    DXCoils::SimDXCoilMultiSpeed(state, CompName, 0.0, PartLoadFrac, this->m_CoolingCoilIndex);
-
-                } else if (CoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                           this->m_CoolCoilName, 
+                                                           FirstHVACIteration,
+                                                           HVAC::CompressorOp::On,
+                                                           PartLoadFrac,
+                                                           this->m_CoolCoilNum,
+                                                           fanOp,
+                                                           HXUnitOn,
+                                                           _,
+                                                           state.dataUnitarySystems->economizerFlag,
+                                                           _,
+                                                           this->m_DehumidificationMode,
+                                                           0.0); // this->CoilSHR);
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) this->m_CompPartLoadRatio = PartLoadFrac;
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
+
+                    DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, 0.0, PartLoadFrac);
+
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
                     this->simMultiSpeedCoils(
-                        state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, CoolingCoil, this->m_SpeedNum);
+                        state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, WhichCoil::Cool, this->m_SpeedNum);
 
-                } else if ((CoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
-                           (CoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
+                } else if ((this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) ||
+                           (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit)) {
 
                     int SpeedNum = 0;
                     this->m_CoolingCoilSensDemand = ReqOutput;
                     VariableSpeedCoils::SimVariableSpeedCoils(
-                        state, "", this->m_CoolingCoilIndex, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, dummy, OnOffAirFlowRatio);
+                        state, this->m_CoolCoilName, this->m_CoolCoilNum, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, dummy, OnOffAirFlowRatio);
 
-                } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
 
                     DXCoils::SimDXCoilMultiMode(
-                        state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadFrac, DehumidMode, this->m_CoolingCoilIndex, fanOp);
+                        state, this->m_CoolCoilName, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadFrac, DehumidMode, this->m_CoolCoilNum, fanOp);
                     this->m_CompPartLoadRatio = PartLoadFrac;
-                } else if (CoilType_Num == HVAC::CoilDX_Cooling) { // CoilCoolingDX
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) { // CoilCoolingDX
                     // SP control (tentatively) operates at constant air flow regardless of speed
                     // speed n uses MSHPMassFlowRateHigh and speed n-1 uses MSHPMassFlowRateLow
                     state.dataHVACGlobal->MSHPMassFlowRateLow = this->m_DesignMassFlowRate;
                     state.dataHVACGlobal->MSHPMassFlowRateHigh = this->m_DesignMassFlowRate;
                     HVAC::CoilMode coilMode = HVAC::CoilMode::Normal;
-                    if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+                    if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                         coilMode = HVAC::CoilMode::SubcoolReheat;
                     } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) {
                         coilMode = HVAC::CoilMode::Enhanced;
                     }
                     bool const singleMode = (this->m_SingleMode == 1);
                     // PartLoadFrac has not been set in this branch - so use m_CoolingSpeedRatio?
-                    state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                    state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                         state, coilMode, this->m_CoolingSpeedNum, this->m_CoolingSpeedRatio, this->m_FanOpMode, singleMode);
                     this->m_CoolCompPartLoadRatio = PartLoadFrac;
-                } else if ((CoilType_Num == HVAC::Coil_CoolingWater) || (CoilType_Num == HVAC::Coil_CoolingWaterDetailed)) { // COIL:COOLING:WATER
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                           this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) { // COIL:COOLING:WATER
 
                     WaterCoils::SimulateWaterCoilComponents(
-                        state, CompName, FirstHVACIteration, this->m_CoolingCoilIndex, _, this->m_FanOpMode, PartLoadFrac);
+                        state, this->m_CoolCoilName, FirstHVACIteration, this->m_CoolCoilNum, _, this->m_FanOpMode, PartLoadFrac);
 
-                } else if (CoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
 
                     WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                    blankString,
-                                                                    this->m_CoolingCoilIndex,
+                                                                    this->m_CoolCoilName,
+                                                                    this->m_CoolCoilNum,
                                                                     ReqOutput,
                                                                     dummy,
                                                                     fanOp,
@@ -12381,11 +11840,10 @@ namespace UnitarySystems {
                                                                     FirstHVACIteration);
                     this->m_CoolingCoilSensDemand = 0.0;
 
-                } else if (CoilType_Num == HVAC::Coil_CoolingWaterToAirHP) {
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHP) {
 
                     WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                        blankString,
-                                                        this->m_CoolingCoilIndex,
+                                                        this->m_CoolCoilNum,
                                                         this->MaxCoolAirMassFlow,
                                                         fanOp,
                                                         FirstHVACIteration,
@@ -12395,16 +11853,16 @@ namespace UnitarySystems {
                                                         HVAC::CompressorOp::Off,
                                                         PartLoadFrac);
 
-                } else if (CoilType_Num == HVAC::Coil_UserDefined) {
+                } else if (this->m_coolCoilType == HVAC::CoilType::UserDefined) {
 
                     bool HeatingActive = false; // set to arbitrary value on entry to function
                     bool CoolingActive = true;  // set to arbitrary value on entry to function
-                    UserDefinedComponents::SimCoilUserDefined(state, CompName, this->m_CoolingCoilIndex, AirLoopNum, HeatingActive, CoolingActive);
+                    UserDefinedComponents::SimCoilUserDefined(state, this->m_CoolCoilName, this->m_CoolCoilNum, AirLoopNum, HeatingActive, CoolingActive);
                     if (CoolingActive) PartLoadFrac = 1.0;
 
-                } else if (CoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling) {
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage) {
 
-                    PackagedThermalStorageCoil::SimTESCoil(state, CompName, this->m_CoolingCoilIndex, fanOp, this->m_TESOpMode, PartLoadFrac);
+                    PackagedThermalStorageCoil::SimTESCoil(state, this->m_CoolCoilName, this->m_CoolCoilNum, fanOp, this->m_TESOpMode, PartLoadFrac);
 
                 } else {
                 }
@@ -12438,7 +11896,7 @@ namespace UnitarySystems {
                         doIt = true;
                     }
                 } else if (this->m_EMSOverrideCoilSpeedNumOn &&
-                           (CoilType_Num == HVAC::CoilDX_MultiSpeedCooling || CoilType_Num == HVAC::CoilDX_Cooling)) {
+                           (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed || this->m_coolCoilType == HVAC::CoilType::CoolingDX)) {
                     // do nothing, PartLoadFrac set above
                 } else if (((NoLoadTempOut - DesOutTemp) < Acc) && ((NoLoadHumRatOut - DesOutHumRat) < HumRatAcc)) {
                     PartLoadFrac = 0.0;
@@ -12451,50 +11909,50 @@ namespace UnitarySystems {
                     PartLoadFrac = 1.0;
                     compressorOp = HVAC::CompressorOp::On;
 
-                    if (CoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) { // COIL:DX:COOLINGBYPASSFACTOREMPIRICAL
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) { // COIL:DX:COOLINGBYPASSFACTOREMPIRICAL
 
                         DXCoils::SimDXCoil(
-                            state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, this->m_CoolingCoilIndex, fanOp, PartLoadFrac);
+                            state, this->m_CoolCoilName, HVAC::CompressorOp::On, FirstHVACIteration, this->m_CoolCoilNum, fanOp, PartLoadFrac);
                         this->m_CompPartLoadRatio = PartLoadFrac;
                         FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat;
 
-                    } else if ((CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) ||
-                               (CoilType_Num == HVAC::CoilWater_CoolingHXAssisted)) { // CoilSystem:Cooling:DX:HeatExchangerAssisted
+                    } else if ((this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) ||
+                               (this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted)) { // CoilSystem:Cooling:DX:HeatExchangerAssisted
 
                         if (this->CoolCoilFluidInletNode > 0)
                             state.dataLoopNodes->Node(this->CoolCoilFluidInletNode).MassFlowRate = max(0.0, this->MaxCoolCoilFluidFlow);
-                        HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                            CompName,
-                                                                            FirstHVACIteration,
-                                                                            HVAC::CompressorOp::On,
-                                                                            PartLoadFrac,
-                                                                            this->m_CoolingCoilIndex,
-                                                                            fanOp,
-                                                                            HXUnitOn,
-                                                                            _,
-                                                                            state.dataUnitarySystems->economizerFlag,
-                                                                            _,
-                                                                            this->m_DehumidificationMode,
-                                                                            0.0); // this->CoilSHR);
-
-                        if (CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) this->m_CompPartLoadRatio = PartLoadFrac;
+                        HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                               this->m_CoolCoilName,
+                                                               FirstHVACIteration,
+                                                               HVAC::CompressorOp::On,
+                                                               PartLoadFrac,
+                                                               this->m_CoolCoilNum,
+                                                               fanOp,
+                                                               HXUnitOn,
+                                                               _,
+                                                               state.dataUnitarySystems->economizerFlag,
+                                                               _,
+                                                               this->m_DehumidificationMode,
+                                                               0.0); // this->CoilSHR);
+
+                        if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) this->m_CompPartLoadRatio = PartLoadFrac;
                         FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat;
 
-                    } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
 
                         CycRatio = 1.0;
                         for (int speedRatio = 0; speedRatio < this->m_NumOfSpeedCooling; ++speedRatio) {
                             SpeedRatio = Real64(speedRatio);
-                            DXCoils::SimDXCoilMultiSpeed(state, CompName, SpeedRatio, CycRatio, this->m_CoolingCoilIndex);
-                            OutletTemp = state.dataDXCoils->DXCoilOutletTemp(this->m_CoolingCoilIndex);
+                            DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, SpeedRatio, CycRatio);
+                            OutletTemp = state.dataDXCoils->DXCoilOutletTemp(this->m_CoolCoilNum);
                             if (SpeedRatio == 1) {
-                                FullLoadHumRatOut = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                FullLoadHumRatOut = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                                 break;
                             }
                             if (OutletTemp < DesOutTemp && SensibleLoad) break;
                         }
 
-                    } else if (CoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
 
                         CycRatio = 1.0;
                         SpeedRatio = 0.0;
@@ -12505,7 +11963,7 @@ namespace UnitarySystems {
                             }
                             this->m_CoolingSpeedNum = SpeedNum;
                             this->simMultiSpeedCoils(
-                                state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, CoolingCoil, SpeedNum);
+                                state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, WhichCoil::Cool, SpeedNum);
                             OutletTemp = state.dataLoopNodes->Node(OutletNode).Temp;
                             if (SpeedNum == this->m_NumOfSpeedCooling) {
                                 FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat;
@@ -12513,8 +11971,8 @@ namespace UnitarySystems {
                             if (OutletTemp < DesOutTemp && SensibleLoad) break;
                         }
 
-                    } else if ((CoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
-                               (CoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
+                    } else if ((this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) ||
+                               (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit)) {
 
                         CycRatio = 1.0;
                         SpeedRatio = 1.0;
@@ -12524,8 +11982,7 @@ namespace UnitarySystems {
                         for (int SpeedNum = 1; SpeedNum <= this->m_NumOfSpeedCooling; ++SpeedNum) {
                             this->m_CoolingSpeedNum = SpeedNum;
                             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                      "",
-                                                                      this->m_CoolingCoilIndex,
+                                                                      this->m_CoolCoilNum,
                                                                       fanOp,
                                                                       compressorOp,
                                                                       CycRatio,
@@ -12548,15 +12005,15 @@ namespace UnitarySystems {
                             SpeedRatio = 1.0;
                         }
 
-                    } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) { // Coil:Cooling:DX:TwoStageWithHumidityControlMode
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) { // Coil:Cooling:DX:TwoStageWithHumidityControlMode
 
                         DXCoils::SimDXCoilMultiMode(
-                            state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadFrac, DehumidMode, this->m_CoolingCoilIndex, fanOp);
+                            state, this->m_CoolCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadFrac, DehumidMode, fanOp);
                         this->m_CompPartLoadRatio = PartLoadFrac;
 
-                    } else if (CoilType_Num == HVAC::CoilDX_Cooling) { // CoilCoolingDX
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) { // CoilCoolingDX
                         HVAC::CoilMode coilMode = HVAC::CoilMode::Normal;
-                        if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+                        if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                             coilMode = HVAC::CoilMode::SubcoolReheat;
                         } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) {
                             coilMode = HVAC::CoilMode::Enhanced;
@@ -12565,7 +12022,7 @@ namespace UnitarySystems {
                         bool const singleMode = (this->m_SingleMode == 1);
                         for (int speedNum = 1; speedNum <= this->m_NumOfSpeedCooling; speedNum++) {
                             this->m_CoolingSpeedNum = speedNum;
-                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                                 state, coilMode, this->m_CoolingSpeedNum, this->m_CoolingSpeedRatio, this->m_FanOpMode, singleMode);
                             if (speedNum == this->m_NumOfSpeedCooling) {
                                 FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat;
@@ -12582,21 +12039,21 @@ namespace UnitarySystems {
                             this->m_CompPartLoadRatio = 1.0;
                             this->m_CoolCompPartLoadRatio = 1.0;
                         }
-                    } else if ((CoilType_Num == HVAC::Coil_CoolingWater) || (CoilType_Num == HVAC::Coil_CoolingWaterDetailed)) { // COIL:COOLING:WATER
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                               this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) { // COIL:COOLING:WATER
 
                         mdot = this->MaxCoolCoilFluidFlow;
                         PlantUtilities::SetComponentFlowRate(
                             state, mdot, this->CoolCoilFluidInletNode, this->CoolCoilFluidOutletNodeNum, this->CoolCoilPlantLoc);
 
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, CompName, FirstHVACIteration, this->m_CoolingCoilIndex, _, this->m_FanOpMode, PartLoadFrac);
+                            state, this->m_CoolCoilNum, FirstHVACIteration, _, this->m_FanOpMode, PartLoadFrac);
                         FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat;
 
-                    } else if (CoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
 
                         WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                        blankString,
-                                                                        this->m_CoolingCoilIndex,
+                                                                        this->m_CoolCoilNum,
                                                                         ReqOutput,
                                                                         dummy,
                                                                         fanOp,
@@ -12606,11 +12063,10 @@ namespace UnitarySystems {
                         this->m_CoolingCoilSensDemand = ReqOutput;
                         FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat;
 
-                    } else if (CoilType_Num == HVAC::Coil_CoolingWaterToAirHP) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHP) {
 
                         WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                            blankString,
-                                                            this->m_CoolingCoilIndex,
+                                                            this->m_CoolCoilNum,
                                                             this->MaxCoolAirMassFlow,
                                                             fanOp,
                                                             FirstHVACIteration,
@@ -12621,15 +12077,15 @@ namespace UnitarySystems {
                                                             PartLoadFrac);
                         FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat;
 
-                    } else if (CoilType_Num == HVAC::Coil_UserDefined) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::UserDefined) {
                         bool HeatingActive = false; // set to arbitrary value on entry to function
                         bool CoolingActive = false; // set to arbitrary value on entry to function
 
                         UserDefinedComponents::SimCoilUserDefined(
-                            state, CompName, this->m_CoolingCoilIndex, AirLoopNum, HeatingActive, CoolingActive);
+                            state, this->m_CoolCoilNum, AirLoopNum, HeatingActive, CoolingActive);
                         if (CoolingActive) PartLoadFrac = 1.0;
 
-                    } else if (CoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage) {
 
                         // TES coil simulated above with PLR=0. Operating mode is known here, no need to simulate again to determine operating
                         // mode.
@@ -12638,7 +12094,7 @@ namespace UnitarySystems {
                             PartLoadFrac = 0.0;
                         } else {
                             // Get full load result
-                            PackagedThermalStorageCoil::SimTESCoil(state, CompName, this->m_CoolingCoilIndex, fanOp, this->m_TESOpMode, PartLoadFrac);
+                            PackagedThermalStorageCoil::SimTESCoil(state, this->m_CoolCoilNum, fanOp, this->m_TESOpMode, PartLoadFrac);
                         }
 
                     } else {
@@ -12669,12 +12125,12 @@ namespace UnitarySystems {
                 if (doIt) {
                     if (unitSys && state.dataLoopNodes->Node(OutletNode).Temp > DesOutTemp - tempAcc) {
                         PartLoadFrac = 1.0;
-                        if (CoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling &&
+                        if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage &&
                             (this->m_TESOpMode == PackagedThermalStorageCoil::PTSCOperatingMode::Off ||
                              this->m_TESOpMode == PackagedThermalStorageCoil::PTSCOperatingMode::ChargeOnly)) {
                             PartLoadFrac = 0.0;
                         }
-                    } else if (CoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling &&
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage &&
                                (this->m_TESOpMode == PackagedThermalStorageCoil::PTSCOperatingMode::Off ||
                                 this->m_TESOpMode == PackagedThermalStorageCoil::PTSCOperatingMode::ChargeOnly)) {
                         PartLoadFrac = 0.0;
@@ -12682,9 +12138,9 @@ namespace UnitarySystems {
                         PartLoadFrac = 0.0;
                     } else {
 
-                        if (CoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
+                        if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                             auto f = [&state, this, DesOutTemp, fanOp](Real64 const PartLoadRatio) {
-                                int CoilIndex = this->m_CoolingCoilIndex;
+                                int CoilIndex = this->m_CoolCoilNum;
                                 DXCoils::CalcDoe2DXCoil(state, CoilIndex, HVAC::CompressorOp::On, true, PartLoadRatio, fanOp);
                                 Real64 OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(CoilIndex);
 
@@ -12693,15 +12149,16 @@ namespace UnitarySystems {
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                             this->m_CompPartLoadRatio = PartLoadFrac;
 
-                        } else if ((CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) || (CoilType_Num == HVAC::CoilWater_CoolingHXAssisted)) {
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted || 
+                                   this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
 
                             auto f = [&state, this, DesOutTemp, FirstHVACIteration, HXUnitOn, fanOp](Real64 const PartLoadFrac) {
                                 if (this->CoolCoilFluidInletNode > 0) {
                                     state.dataLoopNodes->Node(this->CoolCoilFluidInletNode).MassFlowRate = this->MaxCoolCoilFluidFlow * PartLoadFrac;
                                 }
-                                HVACHXAssistedCoolingCoil::CalcHXAssistedCoolingCoil(
+                                HXAssistCoil::CalcHXAssistedCoolingCoil(
                                     state,
-                                    this->m_CoolingCoilIndex,
+                                    this->m_CoolCoilNum,
                                     FirstHVACIteration,
                                     HVAC::CompressorOp::On,
                                     PartLoadFrac,
@@ -12711,7 +12168,7 @@ namespace UnitarySystems {
                                     _,
                                     this->m_DehumidificationMode, // double(this->m_DehumidificationMode)
                                     0.0);
-                                return DesOutTemp - state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolingCoilIndex);
+                                return DesOutTemp - state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolCoilNum);
                             };
 
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
@@ -12724,20 +12181,19 @@ namespace UnitarySystems {
                                 while ((TempOutletTempDXCoil - DesOutTemp) > 0.0 && TempMaxPLR <= 1.0) {
                                     //                   find upper limit of PLR
                                     TempMaxPLR += 0.1;
-                                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                                        CompName,
-                                                                                        FirstHVACIteration,
-                                                                                        HVAC::CompressorOp::On,
-                                                                                        TempMaxPLR,
-                                                                                        this->m_CoolingCoilIndex,
-                                                                                        fanOp,
-                                                                                        HXUnitOn,
-                                                                                        _,
-                                                                                        state.dataUnitarySystems->economizerFlag,
-                                                                                        _,
-                                                                                        this->m_DehumidificationMode,
-                                                                                        0.0); // this->CoilSHR);
-                                    TempOutletTempDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolingCoilIndex);
+                                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                                           this->m_CoolCoilNum,
+                                                                           FirstHVACIteration,
+                                                                           HVAC::CompressorOp::On,
+                                                                           TempMaxPLR,
+                                                                           fanOp,
+                                                                           HXUnitOn,
+                                                                           _,
+                                                                           state.dataUnitarySystems->economizerFlag,
+                                                                           _,
+                                                                           this->m_DehumidificationMode,
+                                                                           0.0); // this->CoilSHR);
+                                    TempOutletTempDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolCoilNum);
                                 }
                                 TempMinPLR = TempMaxPLR;
                                 while ((TempOutletTempDXCoil - DesOutTemp) < 0.0 && TempMinPLR >= 0.0) {
@@ -12745,20 +12201,19 @@ namespace UnitarySystems {
                                     TempMaxPLR = TempMinPLR;
                                     // find minimum limit of PLR
                                     TempMinPLR -= 0.01;
-                                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                                        CompName,
-                                                                                        FirstHVACIteration,
-                                                                                        HVAC::CompressorOp::On,
-                                                                                        TempMinPLR,
-                                                                                        this->m_CoolingCoilIndex,
-                                                                                        fanOp,
-                                                                                        HXUnitOn,
-                                                                                        _,
-                                                                                        state.dataUnitarySystems->economizerFlag,
-                                                                                        _,
-                                                                                        this->m_DehumidificationMode,
-                                                                                        0.0); // this->CoilSHR);
-                                    TempOutletTempDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolingCoilIndex);
+                                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                                           this->m_CoolCoilNum,
+                                                                           FirstHVACIteration,
+                                                                           HVAC::CompressorOp::On,
+                                                                           TempMinPLR,
+                                                                           fanOp,
+                                                                           HXUnitOn,
+                                                                           _,
+                                                                           state.dataUnitarySystems->economizerFlag,
+                                                                           _,
+                                                                           this->m_DehumidificationMode,
+                                                                           0.0); // this->CoilSHR);
+                                    TempOutletTempDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolCoilNum);
                                 }
                                 // Relax boundary slightly to assure a solution can be found using RegulaFalsi (i.e. one boundary may
                                 // be very near the desired result)
@@ -12836,13 +12291,13 @@ namespace UnitarySystems {
                                                                    PartLoadFrac);
                                 }
                             }
-                            if (CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) this->m_CompPartLoadRatio = PartLoadFrac;
+                            if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) this->m_CompPartLoadRatio = PartLoadFrac;
 
-                        } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                             this->m_CoolingSpeedRatio = SpeedRatio;
                             if (SpeedRatio == 1.0) {
                                 auto f = [&state, this, DesOutTemp](Real64 const SpeedRatio) {
-                                    int par1 = this->m_CoolingCoilIndex;
+                                    int par1 = this->m_CoolCoilNum;
                                     Real64 par2 = DesOutTemp;
                                     int par3 = this->m_UnitarySysNum;
                                     // 4-7 are not used for TwoSpeed coils, so these shouldn't matter at all
@@ -12864,7 +12319,7 @@ namespace UnitarySystems {
                                     HVAC::CompressorOp par7_compressorOp = HVAC::CompressorOp::On;
                                     return UnitarySys::DXCoilCyclingResidual(state,
                                                                              CycRatio,
-                                                                             this->m_CoolingCoilIndex,
+                                                                             this->m_CoolCoilNum,
                                                                              DesOutTemp,
                                                                              this->m_UnitarySysNum,
                                                                              par4_SpeedRatio,
@@ -12878,11 +12333,11 @@ namespace UnitarySystems {
                                 PartLoadFrac = CycRatio;
                             }
 
-                        } else if (CoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
 
                             if (this->m_CoolingSpeedNum > 1.0) {
                                 auto f = [&state, this, DesOutTemp, CycRatio](Real64 const SpeedRatio) {
-                                    int par1 = this->m_CoolingCoilIndex;
+                                    int par1 = this->m_CoolCoilNum;
                                     Real64 par2 = DesOutTemp;
                                     int par3 = this->m_UnitarySysNum;
                                     Real64 par4_CycRatio = CycRatio;
@@ -12900,7 +12355,7 @@ namespace UnitarySystems {
                                 auto f = [&state, this, DesOutTemp, SpeedRatio, AirLoopNum, FirstHVACIteration](Real64 const CycRatio) {
                                     return UnitarySys::DXCoilCyclingResidual(state,
                                                                              CycRatio,
-                                                                             this->m_CoolingCoilIndex,
+                                                                             this->m_CoolCoilNum,
                                                                              DesOutTemp,
                                                                              this->m_UnitarySysNum,
                                                                              SpeedRatio,
@@ -12914,15 +12369,15 @@ namespace UnitarySystems {
                                 PartLoadFrac = CycRatio;
                             }
 
-                        } else if ((CoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
-                                   (CoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                                   this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
 
                             CycRatio = 1.0;
                             SpeedRatio = 1.0;
 
                             if (this->m_CoolingSpeedNum > 1.0) {
                                 auto f = [&state, this, DesOutTemp, CycRatio](Real64 const SpeedRatio) {
-                                    int par1 = this->m_CoolingCoilIndex;
+                                    int par1 = this->m_CoolCoilNum;
                                     Real64 par2 = DesOutTemp;
                                     int par3 = this->m_UnitarySysNum;
                                     Real64 par4_CycRatio = CycRatio;
@@ -12943,7 +12398,7 @@ namespace UnitarySystems {
                                 auto f = [&state, this, DesOutTemp, SpeedRatio, AirLoopNum, FirstHVACIteration](Real64 const CycRatio) {
                                     return UnitarySys::DXCoilCyclingResidual(state,
                                                                              CycRatio,
-                                                                             this->m_CoolingCoilIndex,
+                                                                             this->m_CoolCoilNum,
                                                                              DesOutTemp,
                                                                              this->m_UnitarySysNum,
                                                                              SpeedRatio,
@@ -12961,21 +12416,22 @@ namespace UnitarySystems {
                                 PartLoadFrac = CycRatio;
                             }
 
-                        } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                             auto f = [&state, this, DesOutTemp, DehumidMode, fanOp](Real64 const PartLoadRatio) {
                                 DXCoils::SimDXCoilMultiMode(
-                                    state, "", HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, this->m_CoolingCoilIndex, fanOp);
-                                return DesOutTemp - state.dataDXCoils->DXCoilOutletTemp(this->m_CoolingCoilIndex);
+                                    state, this->m_CoolCoilNum, HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, fanOp);
+                                return DesOutTemp - state.dataDXCoils->DXCoilOutletTemp(this->m_CoolCoilNum);
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                             this->m_CompPartLoadRatio = PartLoadFrac;
-                        } else if (CoilType_Num == HVAC::CoilDX_Cooling) { // CoilCoolingDX
+
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) { // CoilCoolingDX
                             auto f = [&state, this, DesOutTemp, DehumidMode, fanOp](Real64 const PartLoadRatio) {
                                 bool const singleMode = this->m_SingleMode;
-                                state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                                state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                                     state, DehumidMode, this->m_CoolingSpeedNum, PartLoadRatio, fanOp, singleMode);
                                 Real64 outletCondition =
-                                    state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[m_CoolingCoilIndex].evapOutletNodeIndex).Temp;
+                                    state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[m_CoolCoilNum].evapOutletNodeIndex).Temp;
                                 return DesOutTemp - outletCondition;
                             };
 
@@ -12988,7 +12444,9 @@ namespace UnitarySystems {
                                 PartLoadFrac = 1.0;
                                 this->m_CompPartLoadRatio = 1.0;
                             }
-                        } else if ((CoilType_Num == HVAC::Coil_CoolingWater) || (CoilType_Num == HVAC::Coil_CoolingWaterDetailed)) {
+
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                                   this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
 
                             // calculate max waterside PLR from mdot request above in case plant chokes water flow
                             maxPartLoadFrac =
@@ -13001,28 +12459,29 @@ namespace UnitarySystems {
                                                   this->MaxCoolCoilFluidFlow * PartLoadRatio);
                                 state.dataLoopNodes->Node(this->CoolCoilFluidInletNode).MassFlowRate = mdot;
                                 WaterCoils::SimulateWaterCoilComponents(
-                                    state, this->m_CoolingCoilName, FirstHVACIteration, this->m_CoolingCoilIndex, _, _, PartLoadRatio);
+                                    state, this->m_CoolCoilName, FirstHVACIteration, this->m_CoolCoilNum, _, _, PartLoadRatio);
                                 return DesOutTemp - state.dataLoopNodes->Node(this->CoolCoilOutletNodeNum).Temp;
                             };
 
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, maxPartLoadFrac);
 
-                        } else if ((CoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) || (CoilType_Num == HVAC::Coil_CoolingWaterToAirHP)) {
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple ||
+                                   this->m_coolCoilType == HVAC::CoilType::CoolingWAHP) {
                             this->m_CoolingCoilSensDemand = ReqOutput;
                             auto f = [&state, this, FirstHVACIteration, DesOutTemp, ReqOutput](Real64 const PartLoadRatio) {
                                 return UnitarySys::coolWatertoAirHPTempResidual(
                                     state, PartLoadRatio, this->m_UnitarySysNum, FirstHVACIteration, DesOutTemp, ReqOutput);
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
-                        } else if (CoilType_Num == HVAC::Coil_UserDefined) {
+
+                        } else if (this->m_coolCoilType == HVAC::CoilType::UserDefined) {
                             // do nothing, user defined coil cannot be controlled
 
-                        } else if (CoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling) {
+                        } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage) {
                             auto f = [&state, this, DesOutTemp](Real64 const PartLoadRatio) {
                                 UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[this->m_UnitarySysNum];
                                 PackagedThermalStorageCoil::SimTESCoil(state,
-                                                                       thisSys.m_CoolingCoilName,
-                                                                       thisSys.m_CoolingCoilIndex,
+                                                                       thisSys.m_CoolCoilNum,
                                                                        thisSys.m_FanOpMode,
                                                                        thisSys.m_TESOpMode,
                                                                        PartLoadRatio);
@@ -13030,9 +12489,8 @@ namespace UnitarySystems {
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         } else {
-                            ShowMessage(state, format(" For :{}=\"{}\"", this->UnitType, this->Name));
-                            ShowFatalError(state,
-                                           format("ControlCoolingSystemToSP: Invalid cooling coil type = {}", HVAC::cAllCoilTypes(CoilType_Num)));
+                            // Bad coil type, should not get here
+                            assert(false);
                         }
                     }
                 }
@@ -13054,27 +12512,26 @@ namespace UnitarySystems {
 
                 if (this->m_EMSOverrideCoilSpeedNumOn) {
                     // pass
-                } else if ((CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) ||
-                           (CoilType_Num == HVAC::CoilWater_CoolingHXAssisted)) { // CoilSystem:Cooling:DX:HeatExchangerAssisted,
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted ||
+                           this->m_coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) { // CoilSystem:Cooling:DX:HeatExchangerAssisted,
                                                                                   // CoilSystem:Cooling:Water:HeatExchangerAssisted
                     // Determine required part load when heat exchanger is ON
                     HXUnitOn = true;
                     PartLoadFrac = 1.0;
-                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                        CompName,
-                                                                        FirstHVACIteration,
-                                                                        HVAC::CompressorOp::On,
-                                                                        PartLoadFrac,
-                                                                        this->m_CoolingCoilIndex,
-                                                                        fanOp,
-                                                                        HXUnitOn,
-                                                                        _,
-                                                                        state.dataUnitarySystems->economizerFlag,
-                                                                        _,
-                                                                        this->m_DehumidificationMode,
-                                                                        0.0); // this->CoilSHR);
-
-                    OutletTempDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolingCoilIndex);
+                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                           this->m_CoolCoilNum,
+                                                           FirstHVACIteration,
+                                                           HVAC::CompressorOp::On,
+                                                           PartLoadFrac,
+                                                           fanOp,
+                                                           HXUnitOn,
+                                                           _,
+                                                           state.dataUnitarySystems->economizerFlag,
+                                                           _,
+                                                           this->m_DehumidificationMode,
+                                                           0.0); // this->CoilSHR);
+
+                    OutletTempDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolCoilNum);
 
                     //               FullOutput will be different than the FullOutput determined above during sensible PLR calculations
                     FullOutput = state.dataLoopNodes->Node(InletNode).MassFlowRate *
@@ -13101,8 +12558,8 @@ namespace UnitarySystems {
                             if (thisSys.CoolCoilFluidInletNode > 0) {
                                 state.dataLoopNodes->Node(thisSys.CoolCoilFluidInletNode).MassFlowRate = thisSys.MaxCoolCoilFluidFlow * PartLoadRatio;
                             }
-                            HVACHXAssistedCoolingCoil::CalcHXAssistedCoolingCoil(state,
-                                                                                 this->m_CoolingCoilIndex,
+                            HXAssistCoil::CalcHXAssistedCoolingCoil(state,
+                                                                                 this->m_CoolCoilNum,
                                                                                  FirstHVACIteration,
                                                                                  HVAC::CompressorOp::On,
                                                                                  PartLoadRatio,
@@ -13112,7 +12569,7 @@ namespace UnitarySystems {
                                                                                  _,
                                                                                  this->m_DehumidificationMode, // double(this->m_DehumidificationMode)
                                                                                  0.0);
-                            Real64 OutletAirTemp = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolingCoilIndex);
+                            Real64 OutletAirTemp = state.dataHVACAssistedCC->HXAssistedCoilOutletTemp(this->m_CoolCoilNum);
                             return DesOutTemp - OutletAirTemp;
                         };
 
@@ -13120,14 +12577,14 @@ namespace UnitarySystems {
                     }
                     this->m_CompPartLoadRatio = PartLoadFrac;
 
-                } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
 
                     // Get full load result
                     PartLoadFrac = 1.0;
                     DehumidMode = HVAC::CoilMode::Enhanced;
                     this->m_DehumidificationMode = DehumidMode;
                     DXCoils::SimDXCoilMultiMode(
-                        state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadFrac, DehumidMode, this->m_CoolingCoilIndex, fanOp);
+                        state, this->m_CoolCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, PartLoadFrac, DehumidMode, fanOp);
                     FullOutput = state.dataLoopNodes->Node(InletNode).MassFlowRate *
                                  Psychrometrics::PsyDeltaHSenFnTdb2W2Tdb1W1(state.dataLoopNodes->Node(OutletNode).Temp,
                                                                             state.dataLoopNodes->Node(OutletNode).HumRat,
@@ -13141,8 +12598,8 @@ namespace UnitarySystems {
                     if (FullOutput >= 0) {
                         PartLoadFrac = 0.0;
                     } else {
-                        OutletTempDXCoil = state.dataDXCoils->DXCoilOutletTemp(this->m_CoolingCoilIndex);
-                        OutletHumRatDXCoil = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                        OutletTempDXCoil = state.dataDXCoils->DXCoilOutletTemp(this->m_CoolCoilNum);
+                        OutletHumRatDXCoil = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                         // If sensible load and setpoint cannot be met, set PLR = 1. if no sensible load and
                         // latent load exists and setpoint cannot be met, set PLR = 1.
                         if ((OutletTempDXCoil > (DesOutTemp - (tempAcc * 2.0)) && SensibleLoad && this->m_RunOnSensibleLoad) ||
@@ -13156,25 +12613,25 @@ namespace UnitarySystems {
                             PartLoadFrac = ReqOutput / FullOutput;
                             auto f = [&state, this, DesOutHumRat, DehumidMode, fanOp](Real64 const PartLoadRatio) {
                                 DXCoils::SimDXCoilMultiMode(
-                                    state, "", HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, this->m_CoolingCoilIndex, fanOp);
-                                return DesOutHumRat - state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                    state, "", HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, this->m_CoolCoilNum, fanOp);
+                                return DesOutHumRat - state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         } else { // must be a sensible load so find PLR
                             PartLoadFrac = ReqOutput / FullOutput;
                             auto f = [&state, this, DesOutTemp, DehumidMode, fanOp](Real64 const PartLoadRatio) {
                                 DXCoils::SimDXCoilMultiMode(
-                                    state, "", HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, this->m_CoolingCoilIndex, fanOp);
-                                return DesOutTemp - state.dataDXCoils->DXCoilOutletTemp(this->m_CoolingCoilIndex);
+                                    state, "", HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, this->m_CoolCoilNum, fanOp);
+                                return DesOutTemp - state.dataDXCoils->DXCoilOutletTemp(this->m_CoolCoilNum);
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         }
                     }
                     this->m_CompPartLoadRatio = PartLoadFrac;
 
-                } else if (CoilType_Num == HVAC::CoilDX_Cooling) { // CoilCoolingDX
+                } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) { // CoilCoolingDX
                     HVAC::CoilMode coilMode = HVAC::CoilMode::Enhanced;
-                    if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+                    if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                         coilMode = HVAC::CoilMode::SubcoolReheat;
                     }
                     if (this->m_CoolingSpeedNum == 0) this->m_CoolingSpeedNum = 1;
@@ -13182,7 +12639,7 @@ namespace UnitarySystems {
                     PartLoadFrac = 1.0;
                     for (int speedNum = this->m_CoolingSpeedNum; speedNum <= this->m_NumOfSpeedCooling; speedNum++) {
                         this->m_CoolingSpeedNum = speedNum;
-                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                        state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                             state, coilMode, this->m_CoolingSpeedNum, this->m_CoolingSpeedRatio, this->m_FanOpMode, singleMode);
                         // Cooling: break if outlet temp is lower than DesOutTemp or approaches DesOutTemp to within Acc from above
                         if ((state.dataLoopNodes->Node(OutletNode).Temp - DesOutTemp) < Acc) break;
@@ -13194,11 +12651,10 @@ namespace UnitarySystems {
 
                         auto f = [&state, this, DesOutTemp, fanOp](Real64 const PartLoadFrac) {
                             bool const singleMode = false;
-                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                                 state, HVAC::CoilMode::Enhanced, this->m_CoolingSpeedNum, PartLoadFrac, fanOp, singleMode);
                             Real64 outletCondition =
-                                state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].evapOutletNodeIndex).Temp;
-
+                                state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].evapOutletNodeIndex).Temp;
                             return DesOutTemp - outletCondition;
                         };
 
@@ -13241,15 +12697,16 @@ namespace UnitarySystems {
 
                 } else {
 
-                    if (CoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) {
+                    if (this->m_coolCoilType == HVAC::CoilType::CoolingDXSingleSpeed) {
                         auto f = [&state, this, DesOutHumRat, fanOp](Real64 const PartLoadRatio) {
-                            DXCoils::CalcDoe2DXCoil(state, this->m_CoolingCoilIndex, HVAC::CompressorOp::On, true, PartLoadRatio, fanOp);
-                            Real64 OutletAirHumRat = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                            DXCoils::CalcDoe2DXCoil(state, this->m_CoolCoilNum, HVAC::CompressorOp::On, true, PartLoadRatio, fanOp);
+                            Real64 OutletAirHumRat = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                             return DesOutHumRat - OutletAirHumRat;
                         };
                         General::SolveRoot(state, HumRatAcc, MaxIte, SolFlaLat, PartLoadFrac, f, 0.0, 1.0);
                         this->m_CompPartLoadRatio = PartLoadFrac;
-                    } else if (CoilType_Num == HVAC::CoilDX_CoolingHXAssisted) {
+
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) {
 
                         //               IF NoLoadHumRatOut is lower than (more dehumidification than required) or very near the DesOutHumRat,
                         //               do not run the compressor
@@ -13262,8 +12719,8 @@ namespace UnitarySystems {
                             //               ELSE find the PLR to meet the load
                         } else {
                             auto f = [&state, this, FirstHVACIteration, HXUnitOn, fanOp, DesOutHumRat](Real64 const PartLoadRatio) {
-                                HVACHXAssistedCoolingCoil::CalcHXAssistedCoolingCoil(state,
-                                                                                     this->m_CoolingCoilIndex,
+                                HXAssistCoil::CalcHXAssistedCoolingCoil(state,
+                                                                                     this->m_CoolCoilNum,
                                                                                      FirstHVACIteration,
                                                                                      HVAC::CompressorOp::On,
                                                                                      PartLoadRatio,
@@ -13273,7 +12730,7 @@ namespace UnitarySystems {
                                                                                      state.dataUnitarySystems->economizerFlag,
                                                                                      HVAC::CoilMode::Normal,
                                                                                      0.0);
-                                return DesOutHumRat - state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                return DesOutHumRat - state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(this->m_CoolCoilNum);
                             };
                             General::SolveRoot(state, HumRatAcc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                             if (SolFla == -1) {
@@ -13284,20 +12741,19 @@ namespace UnitarySystems {
                                 while ((OutletHumRatDXCoil - DesOutHumRat) >= 0.0 && TempMaxPLR <= 1.0) {
                                     //                     find upper limit of LatentPLR
                                     TempMaxPLR += 0.1;
-                                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                                        CompName,
-                                                                                        FirstHVACIteration,
-                                                                                        HVAC::CompressorOp::On,
-                                                                                        TempMaxPLR,
-                                                                                        this->m_CoolingCoilIndex,
-                                                                                        fanOp,
-                                                                                        HXUnitOn,
-                                                                                        _,
-                                                                                        state.dataUnitarySystems->economizerFlag,
-                                                                                        _,
-                                                                                        this->m_DehumidificationMode,
-                                                                                        0.0); // this->CoilSHR);
-                                    OutletHumRatDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                                           this->m_CoolCoilNum,
+                                                                           FirstHVACIteration,
+                                                                           HVAC::CompressorOp::On,
+                                                                           TempMaxPLR,
+                                                                           fanOp,
+                                                                           HXUnitOn,
+                                                                           _,
+                                                                           state.dataUnitarySystems->economizerFlag,
+                                                                           _,
+                                                                           this->m_DehumidificationMode,
+                                                                           0.0); // this->CoilSHR);
+                                    OutletHumRatDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(this->m_CoolCoilNum);
                                 }
                                 TempMaxPLR = min(1.0, TempMaxPLR + 0.1);
                                 TempMinPLR = TempMaxPLR;
@@ -13306,20 +12762,19 @@ namespace UnitarySystems {
                                     //                     exceeds SystemMoisuterLoad)
                                     //                     find minimum limit of Latent PLR
                                     TempMinPLR -= 0.02;
-                                    HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                                        CompName,
-                                                                                        FirstHVACIteration,
-                                                                                        HVAC::CompressorOp::On,
-                                                                                        TempMinPLR,
-                                                                                        this->m_CoolingCoilIndex,
-                                                                                        fanOp,
-                                                                                        HXUnitOn,
-                                                                                        _,
-                                                                                        state.dataUnitarySystems->economizerFlag,
-                                                                                        _,
-                                                                                        this->m_DehumidificationMode,
-                                                                                        0.0); // this->CoilSHR);
-                                    OutletHumRatDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                    HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                                           this->m_CoolCoilNum,
+                                                                           FirstHVACIteration,
+                                                                           HVAC::CompressorOp::On,
+                                                                           TempMinPLR,
+                                                                           fanOp,
+                                                                           HXUnitOn,
+                                                                           _,
+                                                                           state.dataUnitarySystems->economizerFlag,
+                                                                           _,
+                                                                           this->m_DehumidificationMode,
+                                                                           0.0); // this->CoilSHR);
+                                    OutletHumRatDXCoil = state.dataHVACAssistedCC->HXAssistedCoilOutletHumRat(this->m_CoolCoilNum);
                                 }
                                 TempMinPLR = max(0.0, TempMinPLR - 0.1);
                                 //                   tighter boundary of solution has been found, CALL RegulaFalsi a second time
@@ -13401,12 +12856,12 @@ namespace UnitarySystems {
                         }
                         this->m_CompPartLoadRatio = PartLoadFrac;
 
-                    } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
 
                         //               Simulate MultiSpeed DX coil at sensible result
-                        DXCoils::SimDXCoilMultiSpeed(state, CompName, SpeedRatio, CycRatio, this->m_CoolingCoilIndex);
+                        DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, SpeedRatio, CycRatio);
 
-                        OutletHumRatDXCoil = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                        OutletHumRatDXCoil = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                         // IF humidity setpoint is not satisfied and humidity control type is CoolReheat,
                         // then overcool to meet moisture load
 
@@ -13415,17 +12870,17 @@ namespace UnitarySystems {
                             CycRatio = 0.0;
                             SpeedRatio = 0.0;
 
-                            DXCoils::SimDXCoilMultiSpeed(state, CompName, 0.0, 1.0, this->m_CoolingCoilIndex);
-                            OutletHumRatLS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                            DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, 0.0, 1.0);
+                            OutletHumRatLS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                             if (OutletHumRatLS > DesOutHumRat) {
                                 CycRatio = 1.0;
-                                DXCoils::SimDXCoilMultiSpeed(state, CompName, 1.0, 1.0, this->m_CoolingCoilIndex);
-                                OutletHumRatHS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, 1.0, 1.0);
+                                OutletHumRatHS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                                 if (OutletHumRatHS < DesOutHumRat) {
                                     auto f = [&state, this, DesOutHumRat](Real64 const SpeedRatio) {
                                         return UnitarySys::DXCoilVarSpeedHumRatResidual(state,
                                                                                         SpeedRatio,
-                                                                                        this->m_CoolingCoilIndex,
+                                                                                        this->m_CoolCoilNum,
                                                                                         DesOutHumRat,
                                                                                         this->m_UnitarySysNum, // int UnitarySysNum,
                                                                                         0.0,                   // Real64 CycRatio,
@@ -13444,7 +12899,7 @@ namespace UnitarySystems {
                                     return UnitarySys::DXCoilCyclingHumRatResidual(
                                         state,
                                         CycRatio, // compressor cycling ratio (1.0 is continuous, 0.0 is off)
-                                        this->m_CoolingCoilIndex,
+                                        this->m_CoolCoilNum,
                                         DesOutHumRat,
                                         this->m_UnitarySysNum, // int UnitarySysNum,
                                         1.0,                   // Real64 CycRatio,
@@ -13457,10 +12912,10 @@ namespace UnitarySystems {
                             }
                         }
 
-                    } else if (CoilType_Num == HVAC::CoilDX_MultiSpeedCooling) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed) {
 
-                        DXCoils::SimDXCoilMultiSpeed(state, CompName, SpeedRatio, CycRatio, this->m_CoolingCoilIndex);
-                        OutletHumRatDXCoil = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                        DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, SpeedRatio, CycRatio);
+                        OutletHumRatDXCoil = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
 
                         // IF humidity setpoint is not satisfied and humidity control type is CoolReheat,
                         // then overcool to meet moisture load
@@ -13470,17 +12925,17 @@ namespace UnitarySystems {
                             CycRatio = 0.0;
                             SpeedRatio = 0.0;
 
-                            DXCoils::SimDXCoilMultiSpeed(state, CompName, 0.0, 1.0, this->m_CoolingCoilIndex);
-                            OutletHumRatLS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                            DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, 0.0, 1.0);
+                            OutletHumRatLS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                             if (OutletHumRatLS > DesOutHumRat) {
                                 CycRatio = 1.0;
-                                DXCoils::SimDXCoilMultiSpeed(state, CompName, 1.0, 1.0, this->m_CoolingCoilIndex);
-                                OutletHumRatHS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                DXCoils::SimDXCoilMultiSpeed(state, this->m_CoolCoilNum, 1.0, 1.0);
+                                OutletHumRatHS = state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                                 if (OutletHumRatHS < DesOutHumRat) {
                                     auto f = [&state, this, DesOutHumRat](Real64 const SpeedRatio) {
                                         return UnitarySys::DXCoilVarSpeedHumRatResidual(state,
                                                                                         SpeedRatio,
-                                                                                        this->m_CoolingCoilIndex,
+                                                                                        this->m_CoolCoilNum,
                                                                                         DesOutHumRat,
                                                                                         this->m_UnitarySysNum, // int UnitarySysNum,
                                                                                         0.0,                   // Real64 CycRatio,
@@ -13498,7 +12953,7 @@ namespace UnitarySystems {
                                     return UnitarySys::DXCoilCyclingHumRatResidual(
                                         state,
                                         CycRatio, // compressor cycling ratio (1.0 is continuous, 0.0 is off)
-                                        this->m_CoolingCoilIndex,
+                                        this->m_CoolCoilNum,
                                         DesOutHumRat,
                                         this->m_UnitarySysNum, // int UnitarySysNum,
                                         0.0,                   // Real64 CycRatio,
@@ -13509,11 +12964,10 @@ namespace UnitarySystems {
                                 General::SolveRoot(state, HumRatAcc, MaxIte, SolFla, CycRatio, f, 0.0, 1.0);
                             }
                         }
-                    } else if ((CoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
-                               (CoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
+                    } else if ((this->m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) ||
+                               (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit)) {
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                  CompName,
-                                                                  this->m_CoolingCoilIndex,
+                                                                  this->m_CoolCoilNum,
                                                                   this->m_FanOpMode,
                                                                   HVAC::CompressorOp::On,
                                                                   CycRatio,
@@ -13529,8 +12983,7 @@ namespace UnitarySystems {
 
                             for (int speedNum = this->m_CoolingSpeedNum; speedNum <= this->m_NumOfSpeedCooling; ++speedNum) {
                                 VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                          CompName,
-                                                                          this->m_CoolingCoilIndex,
+                                                                          this->m_CoolCoilNum,
                                                                           this->m_FanOpMode,
                                                                           HVAC::CompressorOp::On,
                                                                           1.0,
@@ -13552,7 +13005,7 @@ namespace UnitarySystems {
                                         return UnitarySys::DXCoilCyclingHumRatResidual(
                                             state,
                                             CycRatio, // compressor cycling ratio (1.0 is continuous, 0.0 is off)
-                                            this->m_CoolingCoilIndex,
+                                            this->m_CoolCoilNum,
                                             DesOutHumRat,
                                             this->m_UnitarySysNum, // int UnitarySysNum,
                                             1.0,                   // Real64 CycRatio,
@@ -13565,7 +13018,7 @@ namespace UnitarySystems {
                                     auto f = [&state, this, DesOutHumRat](Real64 const SpeedRatio) {
                                         return UnitarySys::DXCoilVarSpeedHumRatResidual(state,
                                                                                         SpeedRatio,
-                                                                                        this->m_CoolingCoilIndex,
+                                                                                        this->m_CoolCoilNum,
                                                                                         DesOutHumRat,
                                                                                         this->m_UnitarySysNum, // int UnitarySysNum,
                                                                                         1.0,                   // Real64 CycRatio,
@@ -13587,7 +13040,7 @@ namespace UnitarySystems {
                             auto f = [&state, this, DesOutHumRat](Real64 const SpeedRatio) {
                                 return UnitarySys::DXCoilVarSpeedHumRatResidual(state,
                                                                                 SpeedRatio,
-                                                                                this->m_CoolingCoilIndex,
+                                                                                this->m_CoolCoilNum,
                                                                                 DesOutHumRat,
                                                                                 this->m_UnitarySysNum, // int UnitarySysNum,
                                                                                 0.0,                   // Real64 CycRatio,
@@ -13597,22 +13050,24 @@ namespace UnitarySystems {
                             };
                             General::SolveRoot(state, HumRatAcc, MaxIte, SolFla, CycRatio, f, 0.0, 1.0);
                         }
-                    } else if (CoilType_Num == HVAC::CoilDX_CoolingTwoStageWHumControl) {
+
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoStageWHumControl) {
                         auto f = [&state, this, DesOutHumRat, DehumidMode, fanOp](Real64 const PartLoadRatio) {
                             DXCoils::SimDXCoilMultiMode(
-                                state, "", HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, this->m_CoolingCoilIndex, fanOp);
-                            return DesOutHumRat - state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolingCoilIndex);
+                                state, this->m_CoolCoilNum ,HVAC::CompressorOp::On, false, PartLoadRatio, DehumidMode, fanOp);
+                            return DesOutHumRat - state.dataDXCoils->DXCoilOutletHumRat(this->m_CoolCoilNum);
                         };
                         General::SolveRoot(state, Acc, MaxIte, SolFlaLat, PartLoadFrac, f, 0.0, 1.0);
                         this->m_CompPartLoadRatio = PartLoadFrac;
-                    } else if (CoilType_Num == HVAC::CoilDX_Cooling) { // CoilCoolingDX
+
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDX) { // CoilCoolingDX
                         HVAC::CoilMode coilMode = HVAC::CoilMode::Normal;
                         if (this->m_CoolingSpeedNum == 0) this->m_CoolingSpeedNum = 1;
                         bool const singleMode = (this->m_SingleMode == 1);
                         PartLoadFrac = 1.0;
                         for (int speedNum = this->m_CoolingSpeedNum; speedNum <= this->m_NumOfSpeedCooling; speedNum++) {
                             this->m_CoolingSpeedNum = speedNum;
-                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                                 state, coilMode, this->m_CoolingSpeedNum, this->m_CoolingSpeedRatio, this->m_FanOpMode, singleMode);
                             // Cooling: break if outlet humrat is lower than DesOutHumRat or approaches DesOutHumRat to within HumRatAcc from above
                             if ((state.dataLoopNodes->Node(OutletNode).HumRat - DesOutHumRat) < HumRatAcc) break;
@@ -13627,10 +13082,10 @@ namespace UnitarySystems {
                                       fanOp         // 3
                             ](Real64 const PartLoadFrac) {
                                 bool const singleMode = false;
-                                state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+                                state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                                     state, HVAC::CoilMode::Normal, this->m_CoolingSpeedNum, PartLoadFrac, fanOp, singleMode);
                                 Real64 outletCondition =
-                                    state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].evapOutletNodeIndex)
+                                    state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].evapOutletNodeIndex)
                                         .HumRat;
                                 return DesOutHumRat - outletCondition;
                             };
@@ -13646,7 +13101,8 @@ namespace UnitarySystems {
                             this->m_CompPartLoadRatio = 1.0;
                         }
 
-                    } else if ((CoilType_Num == HVAC::Coil_CoolingWater) || (CoilType_Num == HVAC::Coil_CoolingWaterDetailed)) { // COIL:COOLING:WATER
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                               this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) { // COIL:COOLING:WATER
 
                         auto f = [&state, this, FirstHVACIteration, DesOutHumRat](Real64 const PartLoadRatio) {
                             UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[this->m_UnitarySysNum];
@@ -13654,22 +13110,22 @@ namespace UnitarySystems {
                                               thisSys.MaxCoolCoilFluidFlow * PartLoadRatio);
                             state.dataLoopNodes->Node(thisSys.CoolCoilFluidInletNode).MassFlowRate = mdot;
                             WaterCoils::SimulateWaterCoilComponents(
-                                state, thisSys.m_CoolingCoilName, FirstHVACIteration, thisSys.m_CoolingCoilIndex, _, _, PartLoadRatio);
+                                state, thisSys.m_CoolCoilName, FirstHVACIteration, thisSys.m_CoolCoilNum, _, _, PartLoadRatio);
                             return DesOutHumRat - state.dataLoopNodes->Node(thisSys.CoolCoilOutletNodeNum).HumRat;
                         };
 
                         General::SolveRoot(state, HumRatAcc, MaxIte, SolFlaLat, PartLoadFrac, f, 0.0, 1.0);
 
-                    } else if ((CoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) || (CoilType_Num == HVAC::Coil_CoolingWaterToAirHP)) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple ||
+                               this->m_coolCoilType == HVAC::CoilType::CoolingWAHP) {
 
                         auto f = [&state, this, FirstHVACIteration, DesOutHumRat, ReqOutput](Real64 const PartLoadRatio) {
                             UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[this->m_UnitarySysNum];
                             thisSys.m_CompPartLoadRatio = PartLoadRatio;
                             Real64 dummy = 0.0;
-                            if (thisSys.m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+                            if (thisSys.m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
                                 WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                                blankString,
-                                                                                thisSys.m_CoolingCoilIndex,
+                                                                                thisSys.m_CoolCoilNum,
                                                                                 ReqOutput,
                                                                                 dummy,
                                                                                 thisSys.m_FanOpMode,
@@ -13678,8 +13134,7 @@ namespace UnitarySystems {
                                                                                 FirstHVACIteration);
                             } else {
                                 WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                                    blankString,
-                                                                    thisSys.m_CoolingCoilIndex,
+                                                                    thisSys.m_CoolCoilNum,
                                                                     thisSys.MaxCoolAirMassFlow,
                                                                     thisSys.m_FanOpMode,
                                                                     FirstHVACIteration,
@@ -13693,16 +13148,14 @@ namespace UnitarySystems {
                         };
                         General::SolveRoot(state, HumRatAcc, MaxIte, SolFlaLat, PartLoadFrac, f, 0.0, 1.0);
 
-                    } else if (CoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling) {
+                    } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXPackagedThermalStorage) {
 
-                        if (CoilType_Num == HVAC::CoilDX_PackagedThermalStorageCooling &&
-                            (this->m_TESOpMode != PackagedThermalStorageCoil::PTSCOperatingMode::Off &&
-                             this->m_TESOpMode != PackagedThermalStorageCoil::PTSCOperatingMode::ChargeOnly)) {
+                        if (this->m_TESOpMode != PackagedThermalStorageCoil::PTSCOperatingMode::Off &&
+                            this->m_TESOpMode != PackagedThermalStorageCoil::PTSCOperatingMode::ChargeOnly) {
                             auto f = [&state, this, DesOutHumRat](Real64 const PartLoadRatio) {
                                 UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[this->m_UnitarySysNum];
                                 PackagedThermalStorageCoil::SimTESCoil(state,
-                                                                       thisSys.m_CoolingCoilName,
-                                                                       thisSys.m_CoolingCoilIndex,
+                                                                       thisSys.m_CoolCoilNum,
                                                                        thisSys.m_FanOpMode,
                                                                        thisSys.m_TESOpMode,
                                                                        PartLoadRatio);
@@ -13820,7 +13273,7 @@ namespace UnitarySystems {
                 max(state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF, LoopDXCoilMaxRTFSave);
         }
 
-        if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWater || this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) {
+        if (this->m_coolCoilType == HVAC::CoilType::CoolingWater || this->m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
             mdot = PartLoadFrac * this->MaxCoolCoilFluidFlow;
             PlantUtilities::SetComponentFlowRate(state, mdot, this->CoolCoilFluidInletNode, this->CoolCoilFluidOutletNodeNum, this->CoolCoilPlantLoc);
         }
@@ -13863,8 +13316,7 @@ namespace UnitarySystems {
         // Retrieve the load on the controlled zone
         int InletNode = this->HeatCoilInletNodeNum;
         int OutletNode = this->HeatCoilOutletNodeNum;
-        std::string CompName = this->m_HeatingCoilName;
-        int CompIndex = this->m_HeatingCoilIndex;
+        std::string CompName = this->m_HeatCoilName;
         HVAC::FanOp fanOp = this->m_FanOpMode;
         Real64 DesOutTemp = this->m_DesiredOutletTemp;
 
@@ -13914,7 +13366,7 @@ namespace UnitarySystems {
         }
 
         // IF there is a fault of coil SAT Sensor
-        if (this->m_FaultyCoilSATFlag) {
+        if (this->m_FaultyCoilSATIndex > 0) {
             // calculate the sensor offset using fault information
             int FaultIndex = this->m_FaultyCoilSATIndex;
             this->m_FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
@@ -13951,21 +13403,23 @@ namespace UnitarySystems {
                 PartLoadFrac = 0.0;
                 compressorOp = HVAC::CompressorOp::Off;
 
-                switch (this->m_HeatingCoilType_Num) {
-                case HVAC::CoilDX_HeatingEmpirical: {
-                    DXCoils::SimDXCoil(state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, CompIndex, fanOp, PartLoadFrac);
+                switch (this->m_heatCoilType) {
+
+                case HVAC::CoilType::HeatingDXSingleSpeed: {
+                    DXCoils::SimDXCoil(state, this->m_HeatCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, fanOp, PartLoadFrac);
                     this->m_CompPartLoadRatio = PartLoadFrac;
                 } break;
-                case HVAC::Coil_UserDefined: {  // do nothing, user defined coil cannot be controlled
+
+                case HVAC::CoilType::UserDefined: {  // do nothing, user defined coil cannot be controlled
                     bool HeatingActive = false; // dummy variable for UserDefined coil which are passed back indicating if coil is on or off.
                     bool CoolingActive = false; // dummy variable for UserDefined coil which are passed back indicating if coil is on or off.
-                    UserDefinedComponents::SimCoilUserDefined(state, CompName, CompIndex, AirLoopNum, HeatingActive, CoolingActive);
+                    UserDefinedComponents::SimCoilUserDefined(state, this->m_HeatCoilNum, AirLoopNum, HeatingActive, CoolingActive);
                     if (HeatingActive) PartLoadFrac = 1.0;
 
                 } break;
-                case HVAC::CoilDX_MultiSpeedHeating:
-                case HVAC::Coil_HeatingElectric_MultiStage:
-                case HVAC::Coil_HeatingGas_MultiStage: {
+                case HVAC::CoilType::HeatingDXMultiSpeed:
+                case HVAC::CoilType::HeatingElectricMultiStage:
+                case HVAC::CoilType::HeatingGasMultiStage: {
                     if (this->m_EMSOverrideCoilSpeedNumOn) {
                         this->m_HeatingSpeedNum = ceil(this->m_EMSOverrideCoilSpeedNumValue);
                         this->m_SpeedNum = this->m_HeatingSpeedNum;
@@ -13977,7 +13431,7 @@ namespace UnitarySystems {
                             useMaxedSpeed = true;
                             ShowRecurringWarningErrorAtEnd(
                                 state,
-                                "Wrong coil speed EMS override value, for unit=\"" + this->m_HeatingCoilName +
+                                "Wrong coil speed EMS override value, for unit=\"" + this->m_HeatCoilName +
                                     "\". Exceeding maximum coil speed level. Speed level is set to the maximum coil speed level allowed.",
                                 this->m_CoilSpeedErrIdx,
                                 this->m_EMSOverrideCoilSpeedNumValue,
@@ -14008,45 +13462,43 @@ namespace UnitarySystems {
                     }
                     bool LatentLoad = false;
                     this->simMultiSpeedCoils(
-                        state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, HeatingCoil, this->m_SpeedNum);
+                        state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, WhichCoil::Heat, this->m_SpeedNum);
                 } break;
-                case HVAC::Coil_HeatingAirToAirVariableSpeed:
-                case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+                case HVAC::CoilType::HeatingDXVariableSpeed:
+                case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
                     int SpeedNum = 0;
                     this->m_HeatingCoilSensDemand = ReqOutput;
                     VariableSpeedCoils::SimVariableSpeedCoils(
-                        state, "", this->m_HeatingCoilIndex, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, dummy);
+                        state, this->m_HeatCoilNum, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, dummy);
                 } break;
-                case HVAC::Coil_HeatingGasOrOtherFuel:
-                case HVAC::Coil_HeatingElectric:
-                case HVAC::Coil_HeatingDesuperheater: {
-                    HeatingCoils::SimulateHeatingCoilComponents(state, CompName, FirstHVACIteration, PartLoadFrac, CompIndex, _, _, fanOp);
+                case HVAC::CoilType::HeatingGasOrOtherFuel:
+                case HVAC::CoilType::HeatingElectric:
+                case HVAC::CoilType::HeatingDesuperheater: {
+                    HeatingCoils::SimulateHeatingCoilComponents(state, this->m_HeatCoilNum, FirstHVACIteration, PartLoadFrac, _, _, fanOp);
                 } break;
-                case HVAC::Coil_HeatingWater: {
+                case HVAC::CoilType::HeatingWater: {
                     WaterCoils::SimulateWaterCoilComponents(
-                        state, CompName, FirstHVACIteration, this->m_HeatingCoilIndex, _, this->m_FanOpMode, PartLoadFrac);
+                        state, CompName, FirstHVACIteration, this->m_HeatCoilNum, _, this->m_FanOpMode, PartLoadFrac);
                 } break;
-                case HVAC::Coil_HeatingSteam: {
+                case HVAC::CoilType::HeatingSteam: {
                     SteamCoils::SimulateSteamCoilComponents(state,
-                                                            CompName,
+                                                            this->m_HeatCoilNum,
                                                             FirstHVACIteration,
-                                                            this->m_HeatingCoilIndex,
                                                             1.0,
                                                             _,
                                                             this->m_FanOpMode,
                                                             PartLoadFrac); // QCoilReq, simulate any load > 0 to get max capacity
                 } break;
-                case HVAC::Coil_HeatingWaterToAirHPSimple: {
+                case HVAC::CoilType::HeatingWAHPSimple: {
                     if (FirstHVACIteration) this->m_CompPartLoadRatio = 1;
                     WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(
-                        state, blankString, CompIndex, ReqOutput, dummy, fanOp, HVAC::CompressorOp::Off, PartLoadFrac, FirstHVACIteration);
+                        state, this->m_HeatCoilNum, ReqOutput, dummy, fanOp, HVAC::CompressorOp::Off, PartLoadFrac, FirstHVACIteration);
                     this->m_CompPartLoadRatio = PartLoadFrac;
                     this->m_HeatingCoilSensDemand = 0.0;
                 } break;
-                case HVAC::Coil_HeatingWaterToAirHP: {
+                case HVAC::CoilType::HeatingWAHP: {
                     WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                        blankString,
-                                                        CompIndex,
+                                                        this->m_HeatCoilNum,
                                                         this->MaxHeatAirMassFlow,
                                                         fanOp,
                                                         FirstHVACIteration,
@@ -14064,7 +13516,7 @@ namespace UnitarySystems {
                 //     IF outlet temp at no load is within ACC of set point, do not run the coil
 
                 if (std::abs(state.dataLoopNodes->Node(OutletNode).Temp - DesOutTemp) < Acc ||
-                    this->m_HeatingCoilType_Num == HVAC::Coil_UserDefined) {
+                    this->m_heatCoilType == HVAC::CoilType::UserDefined) {
                     // do nothing, coil is at the set point.
                 } else if ((state.dataLoopNodes->Node(OutletNode).Temp - DesOutTemp) > Acc) { // IF outlet temp is above set point turn off coil
                     PartLoadFrac = 0.0;
@@ -14074,16 +13526,17 @@ namespace UnitarySystems {
                     PartLoadFrac = 1.0;
                     compressorOp = HVAC::CompressorOp::On;
 
-                    switch (this->m_HeatingCoilType_Num) {
-                    case HVAC::CoilDX_HeatingEmpirical: { // Coil:Heating:DX:SingleSpeed
-                        DXCoils::SimDXCoil(
-                            state, CompName, HVAC::CompressorOp::On, FirstHVACIteration, this->m_HeatingCoilIndex, fanOp, PartLoadFrac);
+                    switch (this->m_heatCoilType) {
+                    case HVAC::CoilType::HeatingDXSingleSpeed: { // Coil:Heating:DX:SingleSpeed
+                        DXCoils::SimDXCoil(state, this->m_HeatCoilNum, HVAC::CompressorOp::On, FirstHVACIteration, fanOp, PartLoadFrac);
                         this->m_CompPartLoadRatio = PartLoadFrac;
                     } break;
-                    case HVAC::Coil_UserDefined: {
+                      
+                    case HVAC::CoilType::UserDefined: {
                         //  should never get here, coil cannot be controlled and has already been simulated
                     } break;
-                    case HVAC::CoilDX_MultiSpeedHeating: {
+
+                    case HVAC::CoilType::HeatingDXMultiSpeed: {
                         CycRatio = 1.0;
                         SpeedRatio = 0.0;
                         int SpeedNum = 0;
@@ -14121,7 +13574,7 @@ namespace UnitarySystems {
                                 }
                             }
                             this->simMultiSpeedCoils(
-                                state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, HeatingCoil, SpeedNum);
+                                state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, WhichCoil::Heat, SpeedNum);
                             OutletTemp = state.dataLoopNodes->Node(OutletNode).Temp;
                         } else {
                             for (SpeedNum = 1; SpeedNum <= this->m_NumOfSpeedHeating; ++SpeedNum) {
@@ -14137,15 +13590,16 @@ namespace UnitarySystems {
                                                          SensibleLoad,
                                                          LatentLoad,
                                                          PartLoadFrac,
-                                                         HeatingCoil,
+                                                         WhichCoil::Heat,
                                                          SpeedNum);
                                 OutletTemp = state.dataLoopNodes->Node(OutletNode).Temp;
                                 if (OutletTemp > DesOutTemp && SensibleLoad) break;
                             }
                         }
                     } break;
-                    case HVAC::Coil_HeatingElectric_MultiStage:
-                    case HVAC::Coil_HeatingGas_MultiStage: {
+                      
+                    case HVAC::CoilType::HeatingElectricMultiStage:
+                    case HVAC::CoilType::HeatingGasMultiStage: {
                         bool LatentLoad = false;
                         CycRatio = 1.0;
                         SpeedRatio = 1.0;
@@ -14155,14 +13609,14 @@ namespace UnitarySystems {
                         for (int SpeedNum = 1; SpeedNum <= this->m_NumOfSpeedHeating; ++SpeedNum) {
                             this->m_HeatingSpeedNum = SpeedNum;
                             this->simMultiSpeedCoils(
-                                state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, HeatingCoil, SpeedNum);
+                                state, AirLoopNum, FirstHVACIteration, compressorOp, SensibleLoad, LatentLoad, PartLoadFrac, WhichCoil::Heat, SpeedNum);
                             OutletTemp = state.dataLoopNodes->Node(OutletNode).Temp;
                             SpeedRatio = double(SpeedNum) - 1.0;
                             if (OutletTemp > DesOutTemp && SensibleLoad) break;
                         }
                     } break;
-                    case HVAC::Coil_HeatingAirToAirVariableSpeed:
-                    case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+                    case HVAC::CoilType::HeatingDXVariableSpeed:
+                    case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
                         CycRatio = 1.0;
                         SpeedRatio = 1.0;
                         SensLoad = 1.0; // turns on coil
@@ -14171,28 +13625,28 @@ namespace UnitarySystems {
                         for (int SpeedNum = 1; SpeedNum <= this->m_NumOfSpeedHeating; ++SpeedNum) {
                             this->m_HeatingSpeedNum = SpeedNum;
                             VariableSpeedCoils::SimVariableSpeedCoils(
-                                state, "", this->m_HeatingCoilIndex, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, dummy);
+                                state, "", this->m_HeatCoilNum, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, dummy);
                             OutletTemp = state.dataLoopNodes->Node(OutletNode).Temp;
                             if (OutletTemp > DesOutTemp && SensibleLoad) break;
                         }
                     } break;
-                    case HVAC::Coil_HeatingGasOrOtherFuel:
-                    case HVAC::Coil_HeatingElectric: {
+                    case HVAC::CoilType::HeatingGasOrOtherFuel:
+                    case HVAC::CoilType::HeatingElectric: {
                         HeatingCoils::SimulateHeatingCoilComponents(
-                            state, CompName, FirstHVACIteration, this->m_DesignHeatingCapacity, CompIndex, _, _, fanOp);
+                            state, this->m_HeatCoilNum, FirstHVACIteration, this->m_DesignHeatingCapacity, _, _, fanOp);
                     } break;
-                    case HVAC::Coil_HeatingDesuperheater: {
-                        HeatingCoils::SimulateHeatingCoilComponents(state, CompName, FirstHVACIteration, ReqOutput, CompIndex, _, _, fanOp);
+                    case HVAC::CoilType::HeatingDesuperheater: {
+                        HeatingCoils::SimulateHeatingCoilComponents(state, this->m_HeatCoilNum, FirstHVACIteration, ReqOutput, _, _, fanOp);
                     } break;
-                    case HVAC::Coil_HeatingWater: {
+                    case HVAC::CoilType::HeatingWater: {
                         mdot = this->MaxHeatCoilFluidFlow;
                         PlantUtilities::SetComponentFlowRate(
                             state, mdot, this->HeatCoilFluidInletNode, this->HeatCoilFluidOutletNodeNum, this->HeatCoilPlantLoc);
 
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, CompName, FirstHVACIteration, this->m_HeatingCoilIndex, _, this->m_FanOpMode, PartLoadFrac);
+                            state, CompName, FirstHVACIteration, this->m_HeatCoilNum, _, this->m_FanOpMode, PartLoadFrac);
                     } break;
-                    case HVAC::Coil_HeatingSteam: {
+                    case HVAC::CoilType::HeatingSteam: {
                         mdot = this->MaxHeatCoilFluidFlow;
                         PlantUtilities::SetComponentFlowRate(
                             state, mdot, this->HeatCoilFluidInletNode, this->HeatCoilFluidOutletNodeNum, this->HeatCoilPlantLoc);
@@ -14200,22 +13654,23 @@ namespace UnitarySystems {
                         SteamCoils::SimulateSteamCoilComponents(state,
                                                                 CompName,
                                                                 FirstHVACIteration,
-                                                                this->m_HeatingCoilIndex,
+                                                                this->m_HeatCoilNum,
                                                                 1.0,
                                                                 _,
                                                                 this->m_FanOpMode,
                                                                 PartLoadFrac); // QCoilReq, simulate any load > 0 to get max capacity
                     } break;
-                    case HVAC::Coil_HeatingWaterToAirHPSimple: {
+
+                    case HVAC::CoilType::HeatingWAHPSimple: {
                         WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(
-                            state, blankString, CompIndex, ReqOutput, dummy, fanOp, HVAC::CompressorOp::On, PartLoadFrac, FirstHVACIteration);
+                            state, this->m_HeatCoilNum, ReqOutput, dummy, fanOp, HVAC::CompressorOp::On, PartLoadFrac, FirstHVACIteration);
                         this->m_HeatingCoilSensDemand = ReqOutput;
                         this->m_CompPartLoadRatio = PartLoadFrac;
                     } break;
-                    case HVAC::Coil_HeatingWaterToAirHP: {
+
+                    case HVAC::CoilType::HeatingWAHP: {
                         WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                            blankString,
-                                                            CompIndex,
+                                                            this->m_HeatCoilNum,
                                                             this->MaxHeatAirMassFlow,
                                                             fanOp,
                                                             FirstHVACIteration,
@@ -14237,31 +13692,32 @@ namespace UnitarySystems {
                                                                             state.dataLoopNodes->Node(InletNode).HumRat);
                     //       If the outlet temp is within ACC of set point,
                     if (std::abs(state.dataLoopNodes->Node(OutletNode).Temp - DesOutTemp) < Acc ||
-                        this->m_HeatingCoilType_Num == HVAC::Coil_UserDefined) {
+                        this->m_heatCoilType == HVAC::CoilType::UserDefined) {
                         // do nothing, coil is at set point
                     } else if (state.dataLoopNodes->Node(OutletNode).Temp < (DesOutTemp - Acc)) { // IF outlet temp is below set point coil must be on
                         PartLoadFrac = 1.0;
                     } else { // ELSE find the PLR to meet the set point
 
-                        switch (this->m_HeatingCoilType_Num) {
-                        case HVAC::CoilDX_HeatingEmpirical: { // Coil:Heating:DX:SingleSpeed
-                            auto f = [&state, CompIndex, DesOutTemp](Real64 const PartLoadFrac) {
-                                DXCoils::CalcDXHeatingCoil(state, CompIndex, PartLoadFrac, HVAC::FanOp::Continuous, 1.0);
-                                return DesOutTemp - state.dataDXCoils->DXCoilOutletTemp(CompIndex);
+                        switch (this->m_heatCoilType) {
+                        case HVAC::CoilType::HeatingDXSingleSpeed: { // Coil:Heating:DX:SingleSpeed
+                            auto f = [&state, this, DesOutTemp](Real64 const PartLoadFrac) {
+                                DXCoils::CalcDXHeatingCoil(state, this->m_HeatCoilNum, PartLoadFrac, HVAC::FanOp::Continuous, 1.0);
+                                return DesOutTemp - state.dataDXCoils->DXCoilOutletTemp(this->m_HeatCoilNum);
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                             this->m_CompPartLoadRatio = PartLoadFrac;
                         } break;
-                        case HVAC::CoilDX_MultiSpeedHeating:
-                        case HVAC::Coil_HeatingAirToAirVariableSpeed:
-                        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
-                        case HVAC::Coil_HeatingElectric_MultiStage:
-                        case HVAC::Coil_HeatingGas_MultiStage: {
+                          
+                        case HVAC::CoilType::HeatingDXMultiSpeed:
+                        case HVAC::CoilType::HeatingDXVariableSpeed:
+                        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit:
+                        case HVAC::CoilType::HeatingElectricMultiStage:
+                        case HVAC::CoilType::HeatingGasMultiStage: {
                             if (this->m_HeatingSpeedNum > 1.0) {
                                 auto f = [&state, this, DesOutTemp, CycRatio, fanOp](Real64 const SpeedRatio) {
                                     return UnitarySys::heatingCoilVarSpeedResidual(state,
                                                                                    SpeedRatio,
-                                                                                   this->m_HeatingCoilIndex,
+                                                                                   this->m_HeatCoilNum,
                                                                                    DesOutTemp,
                                                                                    this->m_UnitarySysNum,
                                                                                    CycRatio,
@@ -14282,7 +13738,7 @@ namespace UnitarySystems {
                                 auto f = [&state, this, DesOutTemp, SpeedRatio, fanOp](Real64 const CycRatio) {
                                     return UnitarySys::heatingCoilVarSpeedCycResidual(state,
                                                                                       CycRatio,
-                                                                                      this->m_HeatingCoilIndex,
+                                                                                      this->m_HeatCoilNum,
                                                                                       DesOutTemp,
                                                                                       this->m_UnitarySysNum,
                                                                                       SpeedRatio,
@@ -14298,14 +13754,15 @@ namespace UnitarySystems {
                                 PartLoadFrac = CycRatio;
                             }
                         } break;
-                        case HVAC::Coil_HeatingGasOrOtherFuel: {
+                        case HVAC::CoilType::HeatingGasOrOtherFuel: {
                             HeatingCoils::SimulateHeatingCoilComponents(
-                                state, this->m_HeatingCoilName, FirstHVACIteration, ReqOutput, CompIndex, _, true, fanOp, PartLoadFrac);
+                                state, this->m_HeatCoilNum, FirstHVACIteration, ReqOutput, _, true, fanOp, PartLoadFrac);
                             PartLoadFrac = ReqOutput / FullOutput;
                             HeatCoilLoad = ReqOutput;
                         } break;
-                        case HVAC::Coil_HeatingElectric:
-                        case HVAC::Coil_HeatingDesuperheater: {
+                          
+                        case HVAC::CoilType::HeatingElectric:
+                        case HVAC::CoilType::HeatingDesuperheater: {
                             bool tmpSuppHeatingCoilFlag = SuppHeatingCoilFlag; // CONST_LAMBDA_CAPTURE
                             auto f = [&state, this, FirstHVACIteration, DesOutTemp, fanOp, tmpSuppHeatingCoilFlag](Real64 const PartLoadFrac) {
                                 return this->gasElecHeatingCoilResidual(state,
@@ -14319,7 +13776,7 @@ namespace UnitarySystems {
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         } break;
-                        case HVAC::Coil_HeatingWater: {
+                        case HVAC::CoilType::HeatingWater: {
 
                             // calculate max waterside PLR from mdot request above in case plant chokes water flow
                             maxPartLoadFrac =
@@ -14334,9 +13791,9 @@ namespace UnitarySystems {
                                                   this->MaxHeatCoilFluidFlow * maxPartLoadFrac);
                                 state.dataLoopNodes->Node(this->HeatCoilFluidInletNode).MassFlowRate = mdot;
                                 WaterCoils::SimulateWaterCoilComponents(state,
-                                                                        this->m_HeatingCoilName,
+                                                                        this->m_HeatCoilName,
                                                                         FirstHVACIteration,
-                                                                        this->m_HeatingCoilIndex,
+                                                                        this->m_HeatCoilNum,
                                                                         0.0, // QActual
                                                                         this->m_FanOpMode,
                                                                         maxPartLoadFrac);
@@ -14345,7 +13802,7 @@ namespace UnitarySystems {
                             };
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, maxPartLoadFrac);
                         } break;
-                        case HVAC::Coil_HeatingSteam: {
+                        case HVAC::CoilType::HeatingSteam: {
 
                             // calculate max waterside PLR from mdot request above in case plant chokes water flow
                             maxPartLoadFrac =
@@ -14361,9 +13818,9 @@ namespace UnitarySystems {
                                            this->MaxHeatCoilFluidFlow * PartLoadFrac);
                                 state.dataLoopNodes->Node(this->HeatCoilFluidInletNode).MassFlowRate = mdot;
                                 SteamCoils::SimulateSteamCoilComponents(state,
-                                                                        this->m_HeatingCoilName,
+                                                                        this->m_HeatCoilName,
                                                                         FirstHVACIteration,
-                                                                        this->m_HeatingCoilIndex,
+                                                                        this->m_HeatCoilNum,
                                                                         1.0,
                                                                         _,
                                                                         this->m_FanOpMode,
@@ -14374,8 +13831,8 @@ namespace UnitarySystems {
 
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, maxPartLoadFrac);
                         } break;
-                        case HVAC::Coil_HeatingWaterToAirHPSimple:
-                        case HVAC::Coil_HeatingWaterToAirHP: {
+                        case HVAC::CoilType::HeatingWAHPSimple:
+                        case HVAC::CoilType::HeatingWAHP: {
                             this->m_HeatingCoilSensDemand = ReqOutput;
 
                             auto f = [&state, this, FirstHVACIteration, DesOutTemp, ReqOutput](Real64 const PartLoadRatio) {
@@ -14385,10 +13842,9 @@ namespace UnitarySystems {
                                 this->m_CompPartLoadRatio = PartLoadRatio;
 
                                 dummy = 0.0;
-                                if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple) {
+                                if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple) {
                                     WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                                                    blankString,
-                                                                                    this->m_HeatingCoilIndex,
+                                                                                    this->m_HeatCoilNum,
                                                                                     ReqOutput,
                                                                                     dummy,
                                                                                     this->m_FanOpMode,
@@ -14397,8 +13853,7 @@ namespace UnitarySystems {
                                                                                     FirstHVACIteration);
                                 } else {
                                     WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                                        blankString,
-                                                                        this->m_HeatingCoilIndex,
+                                                                        this->m_HeatCoilNum,
                                                                         this->MaxHeatAirMassFlow,
                                                                         this->m_FanOpMode,
                                                                         FirstHVACIteration,
@@ -14415,14 +13870,11 @@ namespace UnitarySystems {
 
                             General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                         } break;
-                        case HVAC::Coil_UserDefined: {
+                        case HVAC::CoilType::UserDefined: {
                             // should never get here, user defined coil cannot be controlled and has already been simulated
                         } break;
                         default: {
-                            ShowMessage(state, format(" For :{}=\"{}\"", this->UnitType, this->Name));
-                            ShowFatalError(
-                                state,
-                                format("ControlHeatingSystemToSP: Invalid heating coil type = {}", HVAC::cAllCoilTypes(this->m_HeatingCoilType_Num)));
+                            assert(false);
                         } break;
                         }
                     }
@@ -14497,7 +13949,7 @@ namespace UnitarySystems {
                 max(state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF, LoopDXCoilMaxRTFSave);
         }
 
-        if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWater || this->m_HeatingCoilType_Num == HVAC::Coil_HeatingSteam) {
+        if (this->m_heatCoilType == HVAC::CoilType::HeatingWater || this->m_heatCoilType == HVAC::CoilType::HeatingSteam) {
             mdot = PartLoadFrac * this->MaxHeatCoilFluidFlow;
             PlantUtilities::SetComponentFlowRate(state, mdot, this->HeatCoilFluidInletNode, this->HeatCoilFluidOutletNodeNum, this->HeatCoilPlantLoc);
         }
@@ -14551,7 +14003,7 @@ namespace UnitarySystems {
         }
 
         // IF there is a fault of coil SAT Sensor
-        if (this->m_FaultyCoilSATFlag) {
+        if (this->m_FaultyCoilSATIndex > 0) {
             // calculate the sensor offset using fault information
             int FaultIndex = this->m_FaultyCoilSATIndex;
             this->m_FaultyCoilSATOffset = state.dataFaultsMgr->FaultsCoilSATSensor(FaultIndex).CalFaultOffsetAct(state);
@@ -14567,27 +14019,26 @@ namespace UnitarySystems {
                 } else {
                     // Get no load result at PartLoadFrac = 0.0
 
-                    switch (this->m_SuppHeatCoilType_Num) {
-                    case HVAC::Coil_HeatingGasOrOtherFuel:
-                    case HVAC::Coil_HeatingElectric:
-                    case HVAC::Coil_HeatingDesuperheater: {
+                    switch (this->m_SuppHeatCoilType) {
+                    case HVAC::CoilType::HeatingGasOrOtherFuel:
+                    case HVAC::CoilType::HeatingElectric:
+                    case HVAC::CoilType::HeatingDesuperheater: {
                         HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                                    CompName,
+                                                                    this->m_SuppHeatCoilNum,
                                                                     FirstHVACIteration,
                                                                     PartLoadFrac,
-                                                                    this->m_SuppHeatCoilIndex,
                                                                     QCoilActual,
                                                                     SuppHeatingCoilFlag,
                                                                     this->m_FanOpMode,
                                                                     PartLoadFrac); // QCoilReq=PartLoadFrac 0.0 for this call
                     } break;
-                    case HVAC::Coil_HeatingElectric_MultiStage: {
+                      
+                    case HVAC::CoilType::HeatingElectricMultiStage: {
                         // SpeedRatio = 0.0;
                         HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                                    CompName,
+                                                                    this->m_SuppHeatCoilNum,
                                                                     FirstHVACIteration,
                                                                     DataLoopNode::SensedLoadFlagValue,
-                                                                    this->m_SuppHeatCoilIndex,
                                                                     QCoilActual,
                                                                     SuppHeatingCoilFlag,
                                                                     this->m_FanOpMode,
@@ -14595,25 +14046,24 @@ namespace UnitarySystems {
                                                                     0,
                                                                     SpeedRatio);
                     } break;
-                    case HVAC::Coil_HeatingWater: {
+                    case HVAC::CoilType::HeatingWater: {
                         WaterCoils::SimulateWaterCoilComponents(
-                            state, CompName, FirstHVACIteration, this->m_SuppHeatCoilIndex, _, this->m_FanOpMode, PartLoadFrac);
+                            state, this->m_SuppHeatCoilNum, FirstHVACIteration, _, this->m_FanOpMode, PartLoadFrac);
                     } break;
-                    case HVAC::Coil_HeatingSteam: {
+                    case HVAC::CoilType::HeatingSteam: {
                         SteamCoils::SimulateSteamCoilComponents(state,
-                                                                CompName,
+                                                                this->m_SuppHeatCoilNum,
                                                                 FirstHVACIteration,
-                                                                this->m_SuppHeatCoilIndex,
                                                                 1.0,
                                                                 _,
                                                                 this->m_FanOpMode,
                                                                 PartLoadFrac); // QCoilReq, simulate any load > 0 to get max capacity
                     } break;
-                    case HVAC::Coil_UserDefined: {  // do nothing, user defined coil cannot be controlled
+                    case HVAC::CoilType::UserDefined: {  // do nothing, user defined coil cannot be controlled
                         bool HeatingActive = false; // dummy variable for UserDefined coil which are passed back indicating if coil is on or off.
                         bool CoolingActive = false; // dummy variable for UserDefined coil which are passed back indicating if coil is on or off.
                         UserDefinedComponents::SimCoilUserDefined(
-                            state, CompName, this->m_SuppHeatCoilIndex, AirLoopNum, HeatingActive, CoolingActive);
+                            state, this->m_SuppHeatCoilNum, AirLoopNum, HeatingActive, CoolingActive);
                         if (HeatingActive) PartLoadFrac = 1.0;
                     } break;
                     default:
@@ -14622,21 +14072,20 @@ namespace UnitarySystems {
 
                     int SolFla = 0;
                     // If OutletTemp is within ACC of set point coil operation is not needed or UserDefined already met load.
-                    if (outletNode.Temp > (DesOutTemp - Acc) || this->m_SuppHeatCoilType_Num == HVAC::Coil_UserDefined) {
+                    if (outletNode.Temp > (DesOutTemp - Acc) || this->m_SuppHeatCoilType == HVAC::CoilType::UserDefined) {
                         // do nothing, coil is at or above set point
                     } else {
                         // outlet temp too low, turn on coil
                         // Get full load result
                         PartLoadFrac = 1.0;
 
-                        switch (this->m_SuppHeatCoilType_Num) {
-                        case HVAC::Coil_HeatingGasOrOtherFuel:
-                        case HVAC::Coil_HeatingElectric: {
+                        switch (this->m_SuppHeatCoilType) {
+                        case HVAC::CoilType::HeatingGasOrOtherFuel:
+                        case HVAC::CoilType::HeatingElectric: {
                             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                                        CompName,
+                                                                        this->m_SuppHeatCoilNum,
                                                                         FirstHVACIteration,
                                                                         this->m_DesignSuppHeatingCapacity,
-                                                                        this->m_SuppHeatCoilIndex,
                                                                         QCoilActual,
                                                                         SuppHeatingCoilFlag,
                                                                         this->m_FanOpMode,
@@ -14645,16 +14094,16 @@ namespace UnitarySystems {
                                 PartLoadFrac = QCoilActual / this->m_DesignSuppHeatingCapacity;
                             }
                         } break;
-                        case HVAC::Coil_HeatingElectric_MultiStage: {
+
+                        case HVAC::CoilType::HeatingElectricMultiStage: {
                             CycRatio = 1.0;
                             SpeedRatio = 1.0;
                             for (int SpeedNum = 1; SpeedNum <= this->m_NumOfSpeedSuppHeating; ++SpeedNum) {
                                 this->m_SuppHeatingSpeedNum = SpeedNum;
                                 HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                                            CompName,
+                                                                            this->m_SuppHeatCoilNum,
                                                                             FirstHVACIteration,
                                                                             DataLoopNode::SensedLoadFlagValue,
-                                                                            this->m_SuppHeatCoilIndex,
                                                                             QCoilActual,
                                                                             SuppHeatingCoilFlag,
                                                                             this->m_FanOpMode,
@@ -14664,39 +14113,37 @@ namespace UnitarySystems {
                                 if (outletNode.Temp > DesOutTemp) break;
                             }
                         } break;
-                        case HVAC::Coil_HeatingDesuperheater: {
+                        case HVAC::CoilType::HeatingDesuperheater: {
                             HeatingCoils::SimulateHeatingCoilComponents(state,
-                                                                        CompName,
+                                                                        this->m_SuppHeatCoilNum,
                                                                         FirstHVACIteration,
                                                                         this->m_DesignSuppHeatingCapacity,
-                                                                        this->m_SuppHeatCoilIndex,
                                                                         _,
                                                                         SuppHeatingCoilFlag,
                                                                         this->m_FanOpMode);
                         } break;
-                        case HVAC::Coil_HeatingWater: {
+                        case HVAC::CoilType::HeatingWater: {
                             mdot = this->m_MaxSuppCoilFluidFlow;
                             PlantUtilities::SetComponentFlowRate(
                                 state, mdot, this->m_SuppCoilFluidInletNode, this->m_SuppCoilFluidOutletNodeNum, this->m_SuppCoilPlantLoc);
 
                             WaterCoils::SimulateWaterCoilComponents(
-                                state, CompName, FirstHVACIteration, this->m_SuppHeatCoilIndex, _, this->m_FanOpMode, PartLoadFrac);
+                                state, this->m_SuppHeatCoilNum, FirstHVACIteration, _, this->m_FanOpMode, PartLoadFrac);
                         } break;
-                        case HVAC::Coil_HeatingSteam: {
+                        case HVAC::CoilType::HeatingSteam: {
                             mdot = this->m_MaxSuppCoilFluidFlow;
                             PlantUtilities::SetComponentFlowRate(
                                 state, mdot, this->m_SuppCoilFluidInletNode, this->m_SuppCoilFluidOutletNodeNum, this->m_SuppCoilPlantLoc);
 
                             SteamCoils::SimulateSteamCoilComponents(state,
-                                                                    CompName,
+                                                                    this->m_SuppHeatCoilNum,
                                                                     FirstHVACIteration,
-                                                                    this->m_SuppHeatCoilIndex,
                                                                     1.0,
                                                                     _,
                                                                     this->m_FanOpMode,
                                                                     PartLoadFrac); // QCoilReq, simulate any load > 0 to get max capacity
                         } break;
-                        case HVAC::Coil_UserDefined: {
+                        case HVAC::CoilType::UserDefined: {
                             //  should never get here, coil has already been simulated
                         } break;
                         default:
@@ -14709,10 +14156,10 @@ namespace UnitarySystems {
                             CycRatio = 1.0;     // change to outletNode.Temp > and removed these vars and the "} else {"
                             SpeedRatio = 1.0;
                         } else {
-                            switch (this->m_SuppHeatCoilType_Num) {
-                            case HVAC::Coil_HeatingGasOrOtherFuel:
-                            case HVAC::Coil_HeatingElectric:
-                            case HVAC::Coil_HeatingDesuperheater: {
+                            switch (this->m_SuppHeatCoilType) {
+                            case HVAC::CoilType::HeatingGasOrOtherFuel:
+                            case HVAC::CoilType::HeatingElectric:
+                            case HVAC::CoilType::HeatingDesuperheater: {
                                 bool tmpSuppHeatingCoilFlag = SuppHeatingCoilFlag; // CONST_LAMBDA_CAPTURE
                                 auto f = [&state, this, FirstHVACIteration, DesOutTemp, tmpSuppHeatingCoilFlag](Real64 const PartLoadFrac) {
                                     return this->gasElecHeatingCoilResidual(state,
@@ -14726,12 +14173,13 @@ namespace UnitarySystems {
                                 };
                                 General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, 1.0);
                             } break;
-                            case HVAC::Coil_HeatingElectric_MultiStage: {
+
+                            case HVAC::CoilType::HeatingElectricMultiStage: {
                                 if (this->m_SuppHeatingSpeedNum > 1) {
                                     auto f = [&state, this, DesOutTemp, CycRatio](Real64 const SpeedRatio) {
                                         return UnitarySys::heatingCoilVarSpeedResidual(state,
                                                                                        SpeedRatio,
-                                                                                       this->m_SuppHeatCoilIndex,
+                                                                                       this->m_SuppHeatCoilNum,
                                                                                        DesOutTemp,
                                                                                        this->m_UnitarySysNum,
                                                                                        CycRatio,
@@ -14748,7 +14196,7 @@ namespace UnitarySystems {
                                     auto f = [&state, this, DesOutTemp, SpeedRatio](Real64 const CycRatio) {
                                         return UnitarySys::heatingCoilVarSpeedCycResidual(state,
                                                                                           CycRatio,
-                                                                                          this->m_SuppHeatCoilIndex,
+                                                                                          this->m_SuppHeatCoilNum, // Why is this not the first parameter after state?
                                                                                           DesOutTemp,
                                                                                           this->m_UnitarySysNum,
                                                                                           SpeedRatio,
@@ -14761,7 +14209,7 @@ namespace UnitarySystems {
                                     PartLoadFrac = CycRatio;
                                 }
                             } break;
-                            case HVAC::Coil_HeatingWater: {
+                            case HVAC::CoilType::HeatingWater: {
                                 // calculate max waterside PLR from mdot request above in case plant chokes water flow
                                 maxPartLoadFrac =
                                     min(1.0,
@@ -14772,9 +14220,8 @@ namespace UnitarySystems {
                                                       this->m_MaxSuppCoilFluidFlow * PartLoadFrac);
                                     state.dataLoopNodes->Node(this->m_SuppCoilFluidInletNode).MassFlowRate = mdot;
                                     WaterCoils::SimulateWaterCoilComponents(state,
-                                                                            this->m_SuppHeatCoilName,
+                                                                            this->m_SuppHeatCoilNum,
                                                                             FirstHVACIteration,
-                                                                            this->m_SuppHeatCoilIndex,
                                                                             0.0, // QActual
                                                                             this->m_FanOpMode,
                                                                             PartLoadFrac);
@@ -14784,7 +14231,7 @@ namespace UnitarySystems {
 
                                 General::SolveRoot(state, Acc, SolveMaxIter, SolFla, PartLoadFrac, f, 0.0, maxPartLoadFrac);
                             } break;
-                            case HVAC::Coil_HeatingSteam: {
+                            case HVAC::CoilType::HeatingSteam: {
 
                                 // calculate max waterside PLR from mdot request above in case plant chokes water flow
                                 maxPartLoadFrac =
@@ -14799,9 +14246,8 @@ namespace UnitarySystems {
                                                this->m_MaxSuppCoilFluidFlow * PartLoadFrac);
                                     state.dataLoopNodes->Node(this->m_SuppCoilFluidInletNode).MassFlowRate = mdot;
                                     SteamCoils::SimulateSteamCoilComponents(state,
-                                                                            this->m_SuppHeatCoilName,
+                                                                            this->m_SuppHeatCoilNum,
                                                                             FirstHVACIteration,
-                                                                            this->m_SuppHeatCoilIndex,
                                                                             1.0,
                                                                             _,
                                                                             this->m_FanOpMode,
@@ -14811,7 +14257,7 @@ namespace UnitarySystems {
 
                                 General::SolveRoot(state, Acc, MaxIte, SolFla, PartLoadFrac, f, 0.0, maxPartLoadFrac);
                             } break;
-                            case HVAC::Coil_UserDefined: {
+                            case HVAC::CoilType::UserDefined: {
                                 //  do nothing, coil has already been simulated
                             } break;
                             default:
@@ -14902,7 +14348,8 @@ namespace UnitarySystems {
             afnInfo.AFNLoopDXCoilRTF = max(afnInfo.AFNLoopDXCoilRTF, LoopDXCoilMaxRTFSave);
         }
 
-        if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingWater || this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingSteam) {
+        if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingWater ||
+            this->m_SuppHeatCoilType == HVAC::CoilType::HeatingSteam) {
             mdot = PartLoadFrac * this->m_MaxSuppCoilFluidFlow;
             PlantUtilities::SetComponentFlowRate(
                 state, mdot, this->m_SuppCoilFluidInletNode, this->m_SuppCoilFluidOutletNodeNum, this->m_SuppCoilPlantLoc);
@@ -14916,7 +14363,7 @@ namespace UnitarySystems {
                                         bool const SensibleLoad,
                                         bool const LatentLoad,
                                         Real64 const PartLoadFrac,
-                                        int const CoilType,
+                                        WhichCoil const whichCoil,
                                         int const SpeedNumber)
     {
 
@@ -14928,20 +14375,18 @@ namespace UnitarySystems {
         // This subroutine manages multispeed and variable speed cooling coil simulation.
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        std::string CompName; // Name of Unitary System object
         Real64 SensLoad = 0.0;
         Real64 LatLoad = 0.0;
-        int CoilTypeNum = 0;
-        int CompIndex = 0;
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;
+        int coilNum = 0;
         Real64 SpeedRatio = 0.0;
         Real64 CycRatio = 0.0;
         Real64 dummy = 0.0;
 
-        if (CoilType == CoolingCoil) {
+        if (whichCoil == WhichCoil::Cool) {
 
-            CompName = this->m_CoolingCoilName;
-            CompIndex = this->m_CoolingCoilIndex;
-            CoilTypeNum = this->m_CoolingCoilType_Num;
+            coilNum = this->m_CoolCoilNum;
+            coilType = this->m_coolCoilType;
             if (SensibleLoad) {
                 SensLoad = -1.0;
                 state.dataUnitarySystems->CoolingLoad = true;
@@ -14951,9 +14396,8 @@ namespace UnitarySystems {
 
         } else {
 
-            CompName = this->m_HeatingCoilName;
-            CompIndex = this->m_HeatingCoilIndex;
-            CoilTypeNum = this->m_HeatingCoilType_Num;
+            coilNum = this->m_HeatCoilNum;
+            coilType = this->m_heatCoilType;
 
             if (SensibleLoad) {
                 SensLoad = 1.0;
@@ -14971,27 +14415,26 @@ namespace UnitarySystems {
 
         this->calcPassiveSystem(state, AirLoopNum, FirstHVACIteration);
 
-        if ((CoilTypeNum == HVAC::CoilDX_MultiSpeedCooling) || (CoilTypeNum == HVAC::CoilDX_MultiSpeedHeating)) {
+        if ((coilType == HVAC::CoilType::CoolingDXMultiSpeed) || (coilType == HVAC::CoilType::HeatingDXMultiSpeed)) {
             DXCoils::SimDXCoilMultiSpeed(
-                state, CompName, 0.0, PartLoadFrac, CompIndex, SpeedNumber, this->m_FanOpMode, HVAC::CompressorOp::On, this->m_SingleMode);
+                state, coilNum, 0.0, PartLoadFrac, SpeedNumber, this->m_FanOpMode, HVAC::CompressorOp::On, this->m_SingleMode);
 
-        } else if (CoilTypeNum == HVAC::CoilDX_Cooling) {
+        } else if (coilType== HVAC::CoilType::CoolingDX) {
             bool const singleMode = (this->m_SingleMode == 1);
             HVAC::CoilMode coilMode = HVAC::CoilMode::Normal;
-            if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+            if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                 coilMode = HVAC::CoilMode::SubcoolReheat;
             } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) {
                 coilMode = HVAC::CoilMode::Enhanced;
             }
 
-            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate(
+            state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].simulate(
                 state, coilMode, this->m_CoolingSpeedNum, PartLoadFrac, this->m_FanOpMode, singleMode, this->CoilSHR);
 
-        } else if (CoilTypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+        } else if (coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      CompName,
-                                                      CompIndex,
+                                                      coilNum,
                                                       this->m_FanOpMode,
                                                       CompressorOn,
                                                       PartLoadFrac,
@@ -15001,11 +14444,10 @@ namespace UnitarySystems {
                                                       dummy,
                                                       OnOffAirFlowRatio);
 
-        } else if (CoilTypeNum == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+        } else if (coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      CompName,
-                                                      CompIndex,
+                                                      coilNum,
                                                       this->m_FanOpMode,
                                                       CompressorOn,
                                                       PartLoadFrac,
@@ -15015,11 +14457,10 @@ namespace UnitarySystems {
                                                       dummy,
                                                       OnOffAirFlowRatio);
 
-        } else if (CoilTypeNum == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
+        } else if (coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      CompName,
-                                                      CompIndex,
+                                                      coilNum,
                                                       this->m_FanOpMode,
                                                       CompressorOn,
                                                       PartLoadFrac,
@@ -15029,11 +14470,10 @@ namespace UnitarySystems {
                                                       dummy,
                                                       OnOffAirFlowRatio);
 
-        } else if (CoilTypeNum == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+        } else if (coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      CompName,
-                                                      CompIndex,
+                                                      coilNum,
                                                       this->m_FanOpMode,
                                                       CompressorOn,
                                                       PartLoadFrac,
@@ -15043,10 +14483,11 @@ namespace UnitarySystems {
                                                       dummy,
                                                       OnOffAirFlowRatio);
 
-        } else if ((CoilTypeNum == HVAC::Coil_HeatingElectric_MultiStage) || (CoilTypeNum == HVAC::Coil_HeatingGas_MultiStage)) {
+        } else if (coilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                   coilType == HVAC::CoilType::HeatingGasMultiStage) {
 
             HeatingCoils::SimulateHeatingCoilComponents(
-                state, CompName, FirstHVACIteration, _, CompIndex, _, _, this->m_FanOpMode, PartLoadFrac, SpeedNumber, this->m_HeatingSpeedRatio);
+                state, coilNum, FirstHVACIteration, _, _, _, this->m_FanOpMode, PartLoadFrac, SpeedNumber, this->m_HeatingSpeedRatio);
         } else {
         }
     }
@@ -15298,8 +14739,8 @@ namespace UnitarySystems {
         Real64 suppHeatingPower = 0.0;
         Real64 defrostElecPower = 0.0;
 
-        switch (this->m_CoolingCoilType_Num) {
-        case HVAC::CoilDX_CoolingTwoSpeed: {
+        switch (this->m_coolCoilType) {
+        case HVAC::CoilType::CoolingDXTwoSpeed: {
             // need to make sure these are 0 for non-variable speed coils (or not report these variables)
             this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
             this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
@@ -15314,7 +14755,8 @@ namespace UnitarySystems {
             }
             elecCoolingPower = state.dataHVACGlobal->DXElecCoolingPower;
         } break;
-        case HVAC::CoilDX_MultiSpeedCooling: {
+          
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
             this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
             this->m_SpeedNum = max(this->m_CoolingSpeedNum, this->m_HeatingSpeedNum);
@@ -15329,8 +14771,8 @@ namespace UnitarySystems {
             }
             elecCoolingPower = state.dataHVACGlobal->DXElecCoolingPower;
         } break;
-        case HVAC::Coil_CoolingWater:
-        case HVAC::Coil_CoolingWaterDetailed: {
+        case HVAC::CoilType::CoolingWater:
+        case HVAC::CoilType::CoolingWaterDetailed: {
             if (this->m_DiscreteSpeedCoolingCoil) {
                 this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
                 this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
@@ -15358,7 +14800,7 @@ namespace UnitarySystems {
             this->m_ElecPowerConsumption = this->m_ElecPower * ReportingConstant;
         } break;
             // May not need
-        case HVAC::Coil_CoolingWaterToAirHPSimple: {
+        case HVAC::CoilType::CoolingWAHPSimple: {
             if (this->m_NumOfSpeedCooling > 1) {
                 this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
                 this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
@@ -15374,7 +14816,7 @@ namespace UnitarySystems {
             }
             elecCoolingPower = state.dataHVACGlobal->DXElecCoolingPower;
         } break;
-        case HVAC::CoilDX_Cooling: {
+        case HVAC::CoilType::CoolingDX: {
             if (this->m_NumOfSpeedCooling > 1) {
                 this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
                 this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
@@ -15390,10 +14832,10 @@ namespace UnitarySystems {
                 }
                 elecCoolingPower = state.dataHVACGlobal->DXElecCoolingPower;
             } else {
-                if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) {
+                if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].SubcoolReheatFlag) {
                     if (state.dataUnitarySystems->CoolingLoad && this->LoadSHR == 0.0) {
                         this->LoadSHR = 1.0;
-                        this->CoilSHR = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].performance.NormalSHR;
+                        this->CoilSHR = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolCoilNum].performance.NormalSHR;
                     }
                 }
                 Real64 CompPartLoadFrac = this->m_CompPartLoadRatio;
@@ -15407,9 +14849,10 @@ namespace UnitarySystems {
                 elecCoolingPower = state.dataHVACGlobal->DXElecCoolingPower;
             }
         } break;
-        case HVAC::Coil_UserDefined:
-        case HVAC::CoilWater_CoolingHXAssisted:
-        case HVAC::CoilDX_PackagedThermalStorageCooling: {
+          
+        case HVAC::CoilType::UserDefined:
+        case HVAC::CoilType::CoolingWaterHXAssisted:
+        case HVAC::CoilType::CoolingDXPackagedThermalStorage: {
             if (state.dataUnitarySystems->CoolingLoad) {
                 this->m_TotalAuxElecPower =
                     this->m_AncillaryOnPower * this->m_PartLoadFrac + this->m_AncillaryOffPower * (1.0 - this->m_PartLoadFrac);
@@ -15433,8 +14876,8 @@ namespace UnitarySystems {
         } break;
         }
 
-        switch (this->m_HeatingCoilType_Num) {
-        case HVAC::CoilDX_MultiSpeedHeating: {
+        switch (this->m_heatCoilType) {
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
             this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
             this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
             this->m_SpeedNum = max(this->m_CoolingSpeedNum, this->m_HeatingSpeedNum);
@@ -15450,8 +14893,9 @@ namespace UnitarySystems {
             elecHeatingPower = state.dataHVACGlobal->DXElecHeatingPower;
             defrostElecPower = state.dataHVACGlobal->DefrostElecPower;
         } break;
-        case HVAC::Coil_HeatingGas_MultiStage:
-        case HVAC::Coil_HeatingElectric_MultiStage: {
+          
+        case HVAC::CoilType::HeatingGasMultiStage:
+        case HVAC::CoilType::HeatingElectricMultiStage: {
             this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
             this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
 
@@ -15466,10 +14910,11 @@ namespace UnitarySystems {
 
             elecHeatingPower = state.dataHVACGlobal->ElecHeatingCoilPower;
         } break;
-        case HVAC::CoilDX_HeatingEmpirical:
-        case HVAC::Coil_HeatingWaterToAirHP:
-        case HVAC::Coil_HeatingWaterToAirHPSimple:
-        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+          
+        case HVAC::CoilType::HeatingDXSingleSpeed:
+        case HVAC::CoilType::HeatingWAHP:
+        case HVAC::CoilType::HeatingWAHPSimple:
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
             if (this->m_NumOfSpeedHeating > 1) {
                 this->m_CycRatio = max(this->m_CoolingCycRatio, this->m_HeatingCycRatio);
                 this->m_SpeedRatio = max(this->m_CoolingSpeedRatio, this->m_HeatingSpeedRatio);
@@ -15486,7 +14931,7 @@ namespace UnitarySystems {
             elecHeatingPower = state.dataHVACGlobal->DXElecHeatingPower;
             defrostElecPower = state.dataHVACGlobal->DefrostElecPower;
         } break;
-        case HVAC::Coil_HeatingAirToAirVariableSpeed: {
+        case HVAC::CoilType::HeatingDXVariableSpeed: {
             if (state.dataUnitarySystems->HeatingLoad) {
                 this->m_TotalAuxElecPower =
                     this->m_AncillaryOnPower * this->m_PartLoadFrac + this->m_AncillaryOffPower * (1.0 - this->m_PartLoadFrac);
@@ -15499,10 +14944,10 @@ namespace UnitarySystems {
             elecHeatingPower = state.dataHVACGlobal->DXElecHeatingPower;
             defrostElecPower = state.dataHVACGlobal->DefrostElecPower;
         } break;
-        case HVAC::Coil_UserDefined:
-        case HVAC::Coil_HeatingWater:
-        case HVAC::Coil_HeatingSteam:
-        case HVAC::Coil_HeatingDesuperheater: {
+        case HVAC::CoilType::UserDefined:
+        case HVAC::CoilType::HeatingWater:
+        case HVAC::CoilType::HeatingSteam:
+        case HVAC::CoilType::HeatingDesuperheater: {
             if (state.dataUnitarySystems->HeatingLoad) {
                 this->m_TotalAuxElecPower =
                     this->m_AncillaryOnPower * this->m_PartLoadFrac + this->m_AncillaryOffPower * (1.0 - this->m_PartLoadFrac);
@@ -15533,7 +14978,8 @@ namespace UnitarySystems {
         }
 
         if (this->m_SuppCoilExists) {
-            if (this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingElectric || this->m_SuppHeatCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage) {
+            if (this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectric ||
+                this->m_SuppHeatCoilType == HVAC::CoilType::HeatingElectricMultiStage) {
                 suppHeatingPower = state.dataHVACGlobal->SuppHeatingCoilPower;
             }
         }
@@ -15713,19 +15159,20 @@ namespace UnitarySystems {
         Real64 SensLoad;
 
         UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[UnitarySysNum];
-        switch (thisSys.m_CoolingCoilType_Num) {
-        case HVAC::CoilDX_CoolingTwoSpeed: {
+        switch (thisSys.m_coolCoilType) {
+        case HVAC::CoilType::CoolingDXTwoSpeed: {
             DXCoils::CalcMultiSpeedDXCoil(state, CoilIndex, SpeedRatio, 1.0);
             OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(CoilIndex);
         } break;
-        case HVAC::CoilDX_MultiSpeedCooling: {
+          
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             OnOffAirFlowRatio = 1.0;
             thisSys.setAverageAirFlow(state, SpeedRatio, OnOffAirFlowRatio);
             DXCoils::CalcMultiSpeedDXCoilCooling(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, compressorOp, 0);
             OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(CoilIndex);
         } break;
-        case HVAC::Coil_CoolingAirToAirVariableSpeed:
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::CoolingDXVariableSpeed:
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
             dummy = 0.0;
             SensLoad = -1.0;
             OnOffAirFlowRatio = 1.0;
@@ -15775,37 +15222,34 @@ namespace UnitarySystems {
 
         UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[UnitarySysNum];
 
-        int heatCoilType = thisSys.m_HeatingCoilType_Num;
-        int heatingCoilOutletNode = thisSys.HeatCoilOutletNodeNum;
-        if (SuppHeat) {
-            heatCoilType = thisSys.m_SuppHeatCoilType_Num;
-            heatingCoilOutletNode = thisSys.SuppCoilOutletNodeNum;
-        }
+        HVAC::CoilType heatCoilType = SuppHeat ? thisSys.m_SuppHeatCoilType : thisSys.m_heatCoilType;
+        int heatCoilOutletNode = SuppHeat ? thisSys.SuppCoilOutletNodeNum : thisSys.HeatCoilOutletNodeNum;
 
         switch (heatCoilType) {
-        case HVAC::CoilDX_MultiSpeedHeating: {
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
             OnOffAirFlowRatio = 1.0;
             thisSys.setAverageAirFlow(state, SpeedRatio, OnOffAirFlowRatio);
             DXCoils::CalcMultiSpeedDXCoilHeating(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, 0);
             OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(CoilIndex);
         } break;
-        case HVAC::Coil_HeatingAirToAirVariableSpeed:
-        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+
+        case HVAC::CoilType::HeatingDXVariableSpeed:
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
             OnOffAirFlowRatio = 1.0;
             SensLoad = 1.0;
             LatLoad = -1.0;
             // can't call only the calc routine with these coil types since Init sets air flow rate based on speed num and cycling ratio
             VariableSpeedCoils::SimVariableSpeedCoils(
-                state, "", CoilIndex, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, LatLoad, OnOffAirFlowRatio);
-            OutletAirTemp = state.dataLoopNodes->Node(heatingCoilOutletNode).Temp;
+                state, CoilIndex, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, LatLoad, OnOffAirFlowRatio);
+            OutletAirTemp = state.dataLoopNodes->Node(heatCoilOutletNode).Temp;
         } break;
-        case HVAC::Coil_HeatingElectric_MultiStage: {
+        case HVAC::CoilType::HeatingElectricMultiStage: {
             HeatingCoils::CalcMultiStageElectricHeatingCoil(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, QActual, SuppHeat);
-            OutletAirTemp = state.dataLoopNodes->Node(heatingCoilOutletNode).Temp;
+            OutletAirTemp = state.dataLoopNodes->Node(heatCoilOutletNode).Temp;
         } break;
-        case HVAC::Coil_HeatingGas_MultiStage: {
+        case HVAC::CoilType::HeatingGasMultiStage: {
             HeatingCoils::CalcMultiStageGasHeatingCoil(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp);
-            OutletAirTemp = state.dataLoopNodes->Node(heatingCoilOutletNode).Temp;
+            OutletAirTemp = state.dataLoopNodes->Node(heatCoilOutletNode).Temp;
         } break;
         default: {
             assert(false);
@@ -15842,19 +15286,20 @@ namespace UnitarySystems {
         Real64 LatLoad;
         Real64 OnOffAirFlowRatio;
         UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[UnitarySysNum];
-        switch (thisSys.m_CoolingCoilType_Num) {
-        case HVAC::CoilDX_CoolingTwoSpeed: {
+        switch (thisSys.m_coolCoilType) {
+        case HVAC::CoilType::CoolingDXTwoSpeed: {
             DXCoils::CalcMultiSpeedDXCoil(state, CoilIndex, SpeedRatio, 1.0);
             OutletAirHumRat = state.dataDXCoils->DXCoilOutletHumRat(CoilIndex);
         } break;
-        case HVAC::CoilDX_MultiSpeedCooling: {
+          
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             OnOffAirFlowRatio = 1.0;
             thisSys.setAverageAirFlow(state, SpeedRatio, OnOffAirFlowRatio);
             DXCoils::CalcMultiSpeedDXCoilCooling(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, compressorOp, 0);
             OutletAirHumRat = state.dataDXCoils->DXCoilOutletHumRat(CoilIndex);
         } break;
-        case HVAC::Coil_CoolingAirToAirVariableSpeed:
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::CoolingDXVariableSpeed:
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
             SensLoad = -1.0;
             LatLoad = 0.0;
             OnOffAirFlowRatio = 1.0;
@@ -15900,8 +15345,8 @@ namespace UnitarySystems {
         Real64 OnOffAirFlowRatio;
 
         UnitarySys &thisSys = state.dataUnitarySystems->unitarySys[UnitarySysNum];
-        switch (thisSys.m_CoolingCoilType_Num) {
-        case HVAC::CoilDX_CoolingTwoSpeed: {
+        switch (thisSys.m_coolCoilType) {
+        case HVAC::CoilType::CoolingDXTwoSpeed: {
             if (thisSys.m_FanPlace == HVAC::FanPlace::BlowThru) { // must simulate fan if blow through since OnOffFanPartLoadFrac affects fan heat
                 thisSys.m_CoolingCycRatio = CycRatio;
                 thisSys.m_CoolingPartLoadFrac = CycRatio;
@@ -15911,7 +15356,8 @@ namespace UnitarySystems {
             }
             OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(CoilIndex);
         } break;
-        case HVAC::CoilDX_MultiSpeedCooling: {
+          
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             OnOffAirFlowRatio = 1.0;
             thisSys.setAverageAirFlow(state, CycRatio, OnOffAirFlowRatio);
             if (thisSys.m_FanPlace == HVAC::FanPlace::BlowThru) { // must simulate fan if blow through since OnOffFanPartLoadFrac affects fan heat
@@ -15923,8 +15369,8 @@ namespace UnitarySystems {
             }
             OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(CoilIndex);
         } break;
-        case HVAC::Coil_CoolingAirToAirVariableSpeed:
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::CoolingDXVariableSpeed:
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
             if (CycRatio == 0.0) compressorOp = HVAC::CompressorOp::Off;
             Real64 dummy = 0.0;
             OnOffAirFlowRatio = 1.0;
@@ -15970,19 +15416,20 @@ namespace UnitarySystems {
         Real64 OnOffAirFlowRatio;
 
         auto &thisSys = state.dataUnitarySystems->unitarySys[UnitarySysNum];
-        switch (thisSys.m_CoolingCoilType_Num) {
-        case HVAC::CoilDX_CoolingTwoSpeed: {
+        switch (thisSys.m_coolCoilType) {
+        case HVAC::CoilType::CoolingDXTwoSpeed: {
             DXCoils::CalcMultiSpeedDXCoil(state, CoilIndex, 0.0, CycRatio);
             OutletAirHumRat = state.dataDXCoils->DXCoilOutletHumRat(CoilIndex);
         } break;
-        case HVAC::CoilDX_MultiSpeedCooling: {
+          
+        case HVAC::CoilType::CoolingDXMultiSpeed: {
             OnOffAirFlowRatio = 1.0;
             thisSys.setAverageAirFlow(state, CycRatio, OnOffAirFlowRatio);
             DXCoils::CalcMultiSpeedDXCoilCooling(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, compressorOp, 0);
             OutletAirHumRat = state.dataDXCoils->DXCoilOutletHumRat(CoilIndex);
         } break;
-        case HVAC::Coil_CoolingAirToAirVariableSpeed:
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::CoolingDXVariableSpeed:
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
             SensLoad = -1.0;
             LatLoad = 0.0;
             OnOffAirFlowRatio = 1.0;
@@ -16029,38 +15476,34 @@ namespace UnitarySystems {
         Real64 QActual;
 
         auto &thisSys = state.dataUnitarySystems->unitarySys[UnitarySysNum];
-
-        int heatCoilType = thisSys.m_HeatingCoilType_Num;
-        int heatingCoilOutletNode = thisSys.HeatCoilOutletNodeNum;
-        if (SuppHeat) {
-            heatCoilType = thisSys.m_SuppHeatCoilType_Num;
-            heatingCoilOutletNode = thisSys.SuppCoilOutletNodeNum;
-        }
+        
+        HVAC::CoilType heatCoilType = SuppHeat ? thisSys.m_SuppHeatCoilType : thisSys.m_heatCoilType;
+        int heatCoilOutletNode = SuppHeat ? thisSys.SuppCoilOutletNodeNum : thisSys.HeatCoilOutletNodeNum;
 
         switch (heatCoilType) {
-        case HVAC::CoilDX_MultiSpeedHeating: {
+        case HVAC::CoilType::HeatingDXMultiSpeed: {
             OnOffAirFlowRatio = 1.0;
             thisSys.setAverageAirFlow(state, CycRatio, OnOffAirFlowRatio);
             DXCoils::CalcMultiSpeedDXCoilHeating(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, 0);
             OutletAirTemp = state.dataDXCoils->DXCoilOutletTemp(CoilIndex);
         } break;
-        case HVAC::Coil_HeatingAirToAirVariableSpeed:
-        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::HeatingDXVariableSpeed:
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
             if (CycRatio == 0.0) compressorOp = HVAC::CompressorOp::Off;
             SensLoad = -1.0;
             LatLoad = 0.0;
             OnOffAirFlowRatio = 1.0;
             VariableSpeedCoils::SimVariableSpeedCoils(
                 state, "", CoilIndex, fanOp, compressorOp, CycRatio, SpeedNum, SpeedRatio, SensLoad, LatLoad, OnOffAirFlowRatio);
-            OutletAirTemp = state.dataLoopNodes->Node(heatingCoilOutletNode).Temp;
+            OutletAirTemp = state.dataLoopNodes->Node(heatCoilOutletNode).Temp;
         } break;
-        case HVAC::Coil_HeatingElectric_MultiStage: {
+        case HVAC::CoilType::HeatingElectricMultiStage: {
             HeatingCoils::CalcMultiStageElectricHeatingCoil(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp, QActual, SuppHeat);
-            OutletAirTemp = state.dataLoopNodes->Node(heatingCoilOutletNode).Temp;
+            OutletAirTemp = state.dataLoopNodes->Node(heatCoilOutletNode).Temp;
         } break;
-        case HVAC::Coil_HeatingGas_MultiStage: {
+        case HVAC::CoilType::HeatingGasMultiStage: {
             HeatingCoils::CalcMultiStageGasHeatingCoil(state, CoilIndex, SpeedRatio, CycRatio, SpeedNum, fanOp);
-            OutletAirTemp = state.dataLoopNodes->Node(heatingCoilOutletNode).Temp;
+            OutletAirTemp = state.dataLoopNodes->Node(heatCoilOutletNode).Temp;
         } break;
         default: {
             assert(false);
@@ -16098,11 +15541,11 @@ namespace UnitarySystems {
         // heating coils using set point control pass DataLoopNode::SensedLoadFlagValue as QCoilReq to indicate temperature control
         if (!SuppHeatingCoilFlag) {
             HeatingCoils::SimulateHeatingCoilComponents(
-                state, thisSys.m_HeatingCoilName, FirstHVACIteration, HeatingLoad, thisSys.m_HeatingCoilIndex, _, _, fanOp, PartLoadFrac);
+                state, thisSys.m_HeatCoilNum, FirstHVACIteration, HeatingLoad, _, _, fanOp, PartLoadFrac);
             return desTemp - state.dataLoopNodes->Node(thisSys.HeatCoilOutletNodeNum).Temp;
         } else {
             HeatingCoils::SimulateHeatingCoilComponents(
-                state, thisSys.m_SuppHeatCoilName, FirstHVACIteration, HeatingLoad, thisSys.m_SuppHeatCoilIndex, _, true, fanOp, PartLoadFrac);
+                state, thisSys.m_SuppHeatCoilNum, FirstHVACIteration, HeatingLoad, _, true, fanOp, PartLoadFrac);
             return desTemp - state.dataLoopNodes->Node(thisSys.SuppCoilOutletNodeNum).Temp;
         }
     }
@@ -16132,10 +15575,9 @@ namespace UnitarySystems {
         thisSys.m_CompPartLoadRatio = PartLoadRatio;
 
         Real64 dummy = 0.0;
-        if (thisSys.m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple) {
+        if (thisSys.m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple) {
             WaterToAirHeatPumpSimple::SimWatertoAirHPSimple(state,
-                                                            blankString,
-                                                            thisSys.m_CoolingCoilIndex,
+                                                            thisSys.m_CoolCoilNum,
                                                             ReqOutput,
                                                             dummy,
                                                             thisSys.m_FanOpMode,
@@ -16144,8 +15586,7 @@ namespace UnitarySystems {
                                                             FirstHVACIteration);
         } else {
             WaterToAirHeatPump::SimWatertoAirHP(state,
-                                                blankString,
-                                                thisSys.m_CoolingCoilIndex,
+                                                thisSys.m_CoolCoilNum,
                                                 thisSys.MaxCoolAirMassFlow,
                                                 thisSys.m_FanOpMode,
                                                 FirstHVACIteration,
@@ -16312,8 +15753,8 @@ namespace UnitarySystems {
                         this->m_HeatingCycRatio = PartLoadRatio;
                     }
                 }
-            } else if (this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                       this->m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHP) {
+            } else if (this->m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple ||
+                       this->m_heatCoilType == HVAC::CoilType::HeatingWAHP) {
                 this->m_CompPartLoadRatio = PartLoadRatio;
                 this->m_HeatingSpeedNum = 0;
             }
@@ -16334,11 +15775,11 @@ namespace UnitarySystems {
                         this->m_CoolingCycRatio = PartLoadRatio;
                     }
                 }
-            } else if (this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple ||
-                       this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHP) {
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple ||
+                       this->m_coolCoilType == HVAC::CoilType::CoolingWAHP) {
                 this->m_CompPartLoadRatio = PartLoadRatio;
                 this->m_CoolingSpeedNum = 0;
-            } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+            } else if (this->m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                 if (this->m_CoolingSpeedNum == 1) {
                     this->m_CoolingSpeedRatio = 0.0;
                     this->m_CoolingCycRatio = PartLoadRatio;
@@ -16383,10 +15824,10 @@ namespace UnitarySystems {
                     if (state.dataUnitarySystems->unitarySys[UnitarySysNum].m_ThisSysInputShouldBeGotten)
                         getUnitarySystemInput(state, UnitarySysName, false, ZoneOAUnitNum);
                     if (state.dataUnitarySystems->unitarySys[UnitarySysNum].m_ISHundredPercentDOASDXCoil) {
-                        if (!(state.dataUnitarySystems->unitarySys[UnitarySysNum].m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed ||
-                              state.dataUnitarySystems->unitarySys[UnitarySysNum].m_CoolingCoilType_Num ==
-                                  HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
-                            DXCoils::SetDXCoilTypeData(state, state.dataUnitarySystems->unitarySys[UnitarySysNum].m_CoolingCoilName);
+                        if (!(state.dataUnitarySystems->unitarySys[UnitarySysNum].m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+                              state.dataUnitarySystems->unitarySys[UnitarySysNum].m_coolCoilType ==
+                                  HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit)) {
+                            DXCoils::SetDXCoilTypeData(state, state.dataUnitarySystems->unitarySys[UnitarySysNum].m_CoolCoilName);
                         }
                     }
                     UnitarySysFound = true;
@@ -16403,8 +15844,8 @@ namespace UnitarySystems {
 
     void UnitarySys::getUnitarySysHeatCoolCoil(EnergyPlusData &state,
                                                std::string_view UnitarySysName, // Name of Unitary System object
-                                               bool &CoolingCoil,               // Cooling coil exists
-                                               bool &HeatingCoil,               // Heating coil exists
+                                               bool &isCoolingCoil,               // Cooling coil exists
+                                               bool &isHeatingCoil,               // Heating coil exists
                                                int const ZoneOAUnitNum          // index to zone OA unit
     )
     {
@@ -16427,11 +15868,11 @@ namespace UnitarySystems {
                     getUnitarySystemInput(state, UnitarySysName, false, ZoneOAUnitNum);
                 if (state.dataUnitarySystems->unitarySys[UnitarySysNum].m_CoolCoilExists &&
                     !state.dataUnitarySystems->unitarySys[UnitarySysNum].m_WaterHRPlantLoopModel) {
-                    CoolingCoil = true;
+                    isCoolingCoil = true;
                 }
                 if (state.dataUnitarySystems->unitarySys[UnitarySysNum].m_HeatCoilExists ||
                     state.dataUnitarySystems->unitarySys[UnitarySysNum].m_SuppCoilExists) {
-                    HeatingCoil = true;
+                    isHeatingCoil = true;
                 }
                 break;
             }
@@ -16578,7 +16019,7 @@ namespace UnitarySystems {
         auto &zoneEquipList = state.dataZoneEquip->ZoneEquipList(zoneEquipConfig.EquipListIndex);
         for (int EquipNum = 1; EquipNum <= zoneEquipList.NumOfEquipTypes; ++EquipNum) {
             if ((zoneEquipList.EquipType(EquipNum) != DataZoneEquipment::ZoneEquipType::UnitarySystem) ||
-                zoneEquipList.EquipName(EquipNum) != thisObjectName) {
+                zoneEquipList.EquipName(EquipNum) != this->Name) {
                 continue;
             }
             this->m_ZoneSequenceCoolingNum = zoneEquipList.CoolingPriority(EquipNum);
@@ -16598,7 +16039,7 @@ namespace UnitarySystems {
             for (int BranchNum = 1; BranchNum <= state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).NumBranches; ++BranchNum) {
                 for (int CompNum = 1; CompNum <= state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).TotalComponents;
                      ++CompNum) {
-                    if (compTypeToFind != state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).CompType_Num)
+                    if (compTypeToFind != state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).compType)
                         continue;
                     if (Util::SameString(state.dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).Name,
                                          objectNameToFind)) {
@@ -16801,9 +16242,9 @@ namespace UnitarySystems {
                                         OutputProcessor::StoreType::Average,
                                         state.dataUnitarySystems->unitarySys[sysNum].Name);
 
-                    switch (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num) {
-                    case HVAC::CoilDX_MultiSpeedCooling:
-                    case HVAC::CoilDX_Cooling: {
+                    switch (state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType) {
+                    case HVAC::CoilType::CoolingDXMultiSpeed:
+                    case HVAC::CoilType::CoolingDX: {
                         if (state.dataUnitarySystems->unitarySys[sysNum].m_HeatRecActive) {
                             SetupOutputVariable(state,
                                                 "Unitary System Heat Recovery Rate",
@@ -16842,10 +16283,10 @@ namespace UnitarySystems {
                                                 state.dataUnitarySystems->unitarySys[sysNum].Name);
                         }
                     } break;
-                    case HVAC::Coil_CoolingAirToAirVariableSpeed:
-                    case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
-                    case HVAC::Coil_CoolingWaterToAirHPSimple:
-                    case HVAC::Coil_CoolingWaterToAirHP: {
+                    case HVAC::CoilType::CoolingDXVariableSpeed:
+                    case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit:
+                    case HVAC::CoilType::CoolingWAHPSimple:
+                    case HVAC::CoilType::CoolingWAHP: {
                         SetupOutputVariable(state,
                                             "Unitary System Requested Sensible Cooling Rate",
                                             Constant::Units::W,
@@ -16865,10 +16306,9 @@ namespace UnitarySystems {
                         break;
                     }
 
-                    if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilIndex >= 0) {
-                        if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_Cooling &&
-                            state.dataCoilCoolingDX->coilCoolingDXs[state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilIndex]
-                                .SubcoolReheatFlag) {
+                    if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolCoilNum >= 0) {
+                        if (state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDX &&
+                            state.dataCoilCoolingDX->coilCoolingDXs[state.dataUnitarySystems->unitarySys[sysNum].m_CoolCoilNum].SubcoolReheatFlag) {
                             SetupOutputVariable(state,
                                                 "Unitary System Zone Load Sensible Heat Ratio",
                                                 Constant::Units::None,
@@ -16886,11 +16326,11 @@ namespace UnitarySystems {
                         }
                     }
 
-                    switch (state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num) {
-                    case HVAC::Coil_HeatingAirToAirVariableSpeed:
-                    case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
-                    case HVAC::Coil_HeatingWaterToAirHPSimple:
-                    case HVAC::Coil_HeatingWaterToAirHP: {
+                    switch (state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType) {
+                    case HVAC::CoilType::HeatingDXVariableSpeed:
+                    case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit:
+                    case HVAC::CoilType::HeatingWAHPSimple:
+                    case HVAC::CoilType::HeatingWAHP: {
                         SetupOutputVariable(state,
                                             "Unitary System Requested Heating Rate",
                                             Constant::Units::W,
@@ -16903,12 +16343,12 @@ namespace UnitarySystems {
                         break;
                     }
 
-                    if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling ||
-                        state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed ||
-                        state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_Cooling ||
-                        state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                        state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num == HVAC::Coil_HeatingElectric_MultiStage ||
-                        state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num == HVAC::Coil_HeatingGas_MultiStage) {
+                    if (state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                        state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed ||
+                        state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDX ||
+                        state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed ||
+                        state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType == HVAC::CoilType::HeatingElectricMultiStage ||
+                        state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType == HVAC::CoilType::HeatingGasMultiStage) {
                         SetupOutputVariable(state,
                                             "Unitary System DX Coil Cycling Ratio",
                                             Constant::Units::None,
@@ -16932,10 +16372,10 @@ namespace UnitarySystems {
                                             state.dataUnitarySystems->unitarySys[sysNum].Name);
                     }
 
-                    if (((state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::Coil_CoolingWater ||
-                          state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterDetailed) &&
+                    if (((state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingWater ||
+                          state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingWaterDetailed) &&
                          state.dataUnitarySystems->unitarySys[sysNum].m_DiscreteSpeedCoolingCoil) ||
-                        (state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num == HVAC::Coil_HeatingWater &&
+                        (state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType == HVAC::CoilType::HeatingWater &&
                          state.dataUnitarySystems->unitarySys[sysNum].m_MultiSpeedHeatingCoil)) {
                         SetupOutputVariable(state,
                                             "Unitary System Water Coil Cycling Ratio",
@@ -17018,9 +16458,9 @@ namespace UnitarySystems {
                                          "[W]",
                                          state.dataUnitarySystems->unitarySys[sysNum].m_EMSOverrideMoistZoneLoadRequest,
                                          state.dataUnitarySystems->unitarySys[sysNum].m_EMSMoistureZoneLoadValue);
-                        if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling ||
-                            state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num == HVAC::CoilDX_MultiSpeedHeating ||
-                            state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) {
+                        if (state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDXMultiSpeed ||
+                            state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType == HVAC::CoilType::HeatingDXMultiSpeed ||
+                            state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDX) {
                             SetupEMSActuator(state,
                                              "Coil Speed Control",
                                              state.dataUnitarySystems->unitarySys[sysNum].Name,
@@ -17042,7 +16482,7 @@ namespace UnitarySystems {
                     break;
                 case UnitarySys::SysType::CoilCoolingDX:
                     // Setup Report variables for the DXCoolingSystem that is not reported in the components themselves
-                    if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_CoolingTwoSpeed) {
+                    if (state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDXTwoSpeed) {
                         SetupOutputVariable(state,
                                             "Coil System Cycling Ratio",
                                             Constant::Units::None,
@@ -17057,7 +16497,7 @@ namespace UnitarySystems {
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Average,
                                             state.dataUnitarySystems->unitarySys[sysNum].Name);
-                    } else if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                    } else if (state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                         SetupOutputVariable(state,
                                             "Coil System Cycling Ratio",
                                             Constant::Units::None,
@@ -17502,11 +16942,11 @@ namespace UnitarySystems {
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
                                         state.dataUnitarySystems->unitarySys[sysNum].Name);
-                    if (((state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPSimple ||
-                          state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) &&
+                    if (((state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingWAHPSimple ||
+                          state.dataUnitarySystems->unitarySys[sysNum].m_coolCoilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) &&
                          state.dataUnitarySystems->unitarySys[sysNum].m_NumOfSpeedCooling > 1) ||
-                        ((state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPSimple ||
-                          state.dataUnitarySystems->unitarySys[sysNum].m_HeatingCoilType_Num == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) &&
+                        ((state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType == HVAC::CoilType::HeatingWAHPSimple ||
+                          state.dataUnitarySystems->unitarySys[sysNum].m_heatCoilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) &&
                          state.dataUnitarySystems->unitarySys[sysNum].m_NumOfSpeedHeating > 1)) {
                         SetupOutputVariable(state,
                                             "Unitary System Water Coil Multispeed Fan Cycling Ratio",
@@ -17689,5 +17129,14 @@ namespace UnitarySystems {
         }
     }
 
+    int getUnitarySysIndex(EnergyPlusData &state, std::string const &unitSysName)
+    {
+        for (int i = 0; i < state.dataUnitarySystems->unitarySys.size(); ++i) {
+            if (Util::SameString(state.dataUnitarySystems->unitarySys[i].Name, unitSysName)) return i;
+        }
+
+        return -1;
+    }
+  
 } // namespace UnitarySystems
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/UnitarySystem.hh b/src/EnergyPlus/UnitarySystem.hh
index 7ed47a4a012..d7e1095bcef 100644
--- a/src/EnergyPlus/UnitarySystem.hh
+++ b/src/EnergyPlus/UnitarySystem.hh
@@ -69,6 +69,14 @@ struct EnergyPlusData;
 
 namespace UnitarySystems {
 
+    // Coil type for SimWater and SimSteamCoil
+    enum class WhichCoil {
+        Cool,
+        Heat,
+        SuppHeat,
+        Num
+    };
+  
     // Supply Air Sizing Option
     int constexpr None = 1;
     int constexpr SupplyAirFlowRate = 2;
@@ -83,6 +91,7 @@ namespace UnitarySystems {
     int constexpr HeatingMode = 2; // last compressor operating mode was in heating
     int constexpr NoCoolHeat = 3;  // last operating mode was no cooling or heating
 
+    // Is this structure automatically generated?
     struct UnitarySysInputSpec
     {
         // system_type is not an object input but the actual type of object (e.g., UnitarySystem, CoilSystem:Cooling:DX, etc.).
@@ -165,6 +174,7 @@ namespace UnitarySystems {
 
     public:
         std::string name;
+        // What is this factory nonsense?
         static DesignSpecMSHP *factory(EnergyPlusData &state, HVAC::UnitarySysType type, std::string const &objectName);
         int numOfSpeedHeating = 0;
         int numOfSpeedCooling = 0;
@@ -257,11 +267,15 @@ namespace UnitarySystems {
         int m_ZoneInletNode = 0;
         int m_ZoneSequenceCoolingNum = 0;
         int m_ZoneSequenceHeatingNum = 0;
+
         bool m_HeatCoilExists = false;
         Real64 m_HeatingSizingRatio = 1.0;
-        int m_HeatingCoilType_Num = 0;
         bool m_DXHeatingCoil = false;
-        int m_HeatingCoilIndex = 0;
+
+        HVAC::CoilType m_heatCoilType = HVAC::CoilType::Invalid;
+        std::string m_HeatCoilName;
+        int m_HeatCoilNum = 0;
+      
         Sched::Schedule *m_heatingCoilAvailSched = nullptr;
         Real64 m_DesignHeatingCapacity = 0.0;
         Real64 m_MaxHeatAirVolFlow = 0.0;
@@ -270,15 +284,23 @@ namespace UnitarySystems {
         bool m_MultiSpeedHeatingCoil = false;
         bool m_VarSpeedHeatingCoil = false;
         int HeatCtrlNode = 0;
+
         bool m_CoolCoilExists = false;
-        int m_CoolingCoilType_Num = 0;
+        std::string m_CoolCoilName;
+        HVAC::CoilType m_coolCoilType = HVAC::CoilType::Invalid;
+        int m_CoolCoilNum = 0;
+
+        std::string m_childCoolCoilName; // if cool coil is HXAssisted, this is the child coil
+        HVAC::CoilType m_childCoolCoilType = HVAC::CoilType::Invalid;
+        int m_childCoolCoilNum = 0;
+      
         int m_NumOfSpeedCooling = 0;
-        Sched::Schedule *m_coolingCoilAvailSched = nullptr;
+        Sched::Schedule *m_coolCoilAvailSched = nullptr;
         Real64 m_DesignCoolingCapacity = 0.0;
         Real64 m_MaxCoolAirVolFlow = 0.0;
         int m_CondenserNodeNum = 0;
         DataHeatBalance::RefrigCondenserType m_CondenserType = DataHeatBalance::RefrigCondenserType::Invalid;
-        int m_CoolingCoilIndex = 0;
+      
         bool m_HeatPump = false;
         int m_ActualDXCoilIndexForHXAssisted = 0;
         bool m_DiscreteSpeedCoolingCoil = false;
@@ -290,14 +312,16 @@ namespace UnitarySystems {
         bool m_RunOnLatentLoad = false;
         bool m_RunOnLatentOnlyWithSensible = false;
         HVAC::CoilMode m_DehumidificationMode = HVAC::CoilMode::Normal; // Only explicitly initialized if something other than Normal
-        int m_SuppHeatCoilType_Num = 0;
+
+        std::string m_SuppHeatCoilName;
+        HVAC::CoilType m_SuppHeatCoilType = HVAC::CoilType::Invalid;
         bool m_SuppCoilExists = false;
         Real64 m_DesignSuppHeatingCapacity = 0.0;
         int m_SuppCoilAirInletNode = 0;
         int SuppCoilOutletNodeNum = 0;
         int m_SuppCoilFluidInletNode = 0;
         Real64 m_MaxSuppCoilFluidFlow = 0.0;
-        int m_SuppHeatCoilIndex = 0;
+        int m_SuppHeatCoilNum = 0;
         int SuppCtrlNode = 0;
         Real64 m_SupHeaterLoad = 0.0;
         int m_CoolingSAFMethod = 0;
@@ -438,7 +462,6 @@ namespace UnitarySystems {
         Real64 m_MoistureLoadPredicted = 0.0;
 
         // Fault model of coil SAT sensor
-        bool m_FaultyCoilSATFlag = false;   // True if the coil has SAT sensor fault
         int m_FaultyCoilSATIndex = 0;       // Index of the fault object corresponding to the coil
         Real64 m_FaultyCoilSATOffset = 0.0; // Coil SAT sensor offset
 
@@ -456,6 +479,9 @@ namespace UnitarySystems {
         bool m_TemperatureOffsetControlActive = false; // true if water-side economizer coil is active
         Real64 m_minAirToWaterTempOffset = 0.0;        // coil entering air to entering water temp offset
 
+        std::string m_HRcoolCoilName;
+        HVAC::CoilType m_HRcoolCoilType = HVAC::CoilType::Invalid;
+        int m_HRcoolCoilNum = 0;
         int m_HRcoolCoilFluidInletNode = 0;
         int m_HRcoolCoilAirInNode = 0;
         Real64 m_minWaterLoopTempForHR = 0.0;   // water coil heat recovery loops
@@ -528,13 +554,9 @@ namespace UnitarySystems {
 
         //    private:
         // private members not initialized in constructor
+        // What is the point of making these private? 
         std::string m_FanName;
         std::string m_ATMixerName;
-        std::string m_HeatingCoilName;
-        std::string m_HeatingCoilTypeName;
-        std::string m_CoolingCoilName;
-        std::string m_SuppHeatCoilName;
-        std::string m_SuppHeatCoilTypeName;
         std::string m_DesignSpecMultispeedHPType;
         std::string m_DesignSpecMultispeedHPName;
         std::vector<Real64> m_CoolVolumeFlowRate;
@@ -699,7 +721,7 @@ namespace UnitarySystems {
         bool checkNodeSetPoint(EnergyPlusData &state,
                                int const AirLoopNum,       // number of the current air loop being simulated
                                int const ControlNode,      // Node to test for set point
-                               int const CoilType,         // True if cooling coil, then test for HumRatMax set point
+                               WhichCoil const whichCoil,         // True if cooling coil, then test for HumRatMax set point
                                Real64 const OAUCoilOutTemp // the coil inlet temperature of OutdoorAirUnit
         );
 
@@ -841,7 +863,7 @@ namespace UnitarySystems {
                                 bool const SensibleLoad,
                                 bool const LatentLoad,
                                 Real64 const PartLoadFrac,
-                                int const CoilType,
+                                WhichCoil const whichCoil,
                                 int const SpeedNumber);
 
         void calcPassiveSystem(EnergyPlusData &state,
@@ -950,6 +972,8 @@ namespace UnitarySystems {
         virtual ~UnitarySys() = default;
     };
 
+    int getUnitarySysIndex(EnergyPlusData &state, std::string const &unitSysName);
+  
     int getDesignSpecMSHPIndex(EnergyPlusData &state, std::string_view objectName);
     int getUnitarySystemIndex(EnergyPlusData &state, std::string_view objectName);
     bool getUnitarySystemNodeNumber(EnergyPlusData &state, int const nodeNumber);
diff --git a/src/EnergyPlus/UserDefinedComponents.cc b/src/EnergyPlus/UserDefinedComponents.cc
index 72d5ec1ce9c..94786cb42ae 100644
--- a/src/EnergyPlus/UserDefinedComponents.cc
+++ b/src/EnergyPlus/UserDefinedComponents.cc
@@ -265,63 +265,74 @@ namespace UserDefinedComponents {
                 state.dataUserDefinedComponents->CheckUserCoilName(CompNum) = false;
             }
         }
+
+        SimCoilUserDefined(state, CompNum, AirLoopNum, HeatingActive, CoolingActive);
+    }
+
+    void SimCoilUserDefined(EnergyPlusData &state,
+                            int coilNum,
+                            int const AirLoopNum,
+                            bool &HeatingActive,
+                            bool &CoolingActive)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataUserDefinedComponents->NumUserCoils);
+        auto &userCoil = state.dataUserDefinedComponents->UserCoil(coilNum);
+        
         bool anyEMSRan;
         if (state.dataGlobal->BeginEnvrnFlag) {
-            if (state.dataUserDefinedComponents->UserCoil(CompNum).ErlInitProgramMngr > 0) {
+            if (userCoil.ErlInitProgramMngr > 0) {
                 EMSManager::ManageEMS(state,
                                       EMSManager::EMSCallFrom::UserDefinedComponentModel,
                                       anyEMSRan,
-                                      state.dataUserDefinedComponents->UserCoil(CompNum).ErlInitProgramMngr);
-            } else if (state.dataUserDefinedComponents->UserCoil(CompNum).initPluginLocation > -1) {
-                state.dataPluginManager->pluginManager->runSingleUserDefinedPlugin(
-                    state, state.dataUserDefinedComponents->UserCoil(CompNum).initPluginLocation);
-            } else if (state.dataUserDefinedComponents->UserCoil(CompNum).initCallbackIndex > -1) {
-                state.dataPluginManager->pluginManager->runSingleUserDefinedCallback(
-                    state, state.dataUserDefinedComponents->UserCoil(CompNum).initCallbackIndex);
+                                      userCoil.ErlInitProgramMngr);
+            } else if (userCoil.initPluginLocation > -1) {
+                state.dataPluginManager->pluginManager->runSingleUserDefinedPlugin(state, userCoil.initPluginLocation);
+            } else if (userCoil.initCallbackIndex > -1) {
+                state.dataPluginManager->pluginManager->runSingleUserDefinedCallback(state, userCoil.initCallbackIndex);
             }
 
-            if (state.dataUserDefinedComponents->UserCoil(CompNum).PlantIsConnected) {
+            if (userCoil.PlantIsConnected) {
 
                 PlantUtilities::InitComponentNodes(state,
-                                                   state.dataUserDefinedComponents->UserCoil(CompNum).Loop.MassFlowRateMin,
-                                                   state.dataUserDefinedComponents->UserCoil(CompNum).Loop.MassFlowRateMax,
-                                                   state.dataUserDefinedComponents->UserCoil(CompNum).Loop.InletNodeNum,
-                                                   state.dataUserDefinedComponents->UserCoil(CompNum).Loop.OutletNodeNum);
+                                                   userCoil.Loop.MassFlowRateMin,
+                                                   userCoil.Loop.MassFlowRateMax,
+                                                   userCoil.Loop.InletNodeNum,
+                                                   userCoil.Loop.OutletNodeNum);
 
                 PlantUtilities::RegisterPlantCompDesignFlow(state,
-                                                            state.dataUserDefinedComponents->UserCoil(CompNum).Loop.InletNodeNum,
-                                                            state.dataUserDefinedComponents->UserCoil(CompNum).Loop.DesignVolumeFlowRate);
+                                                            userCoil.Loop.InletNodeNum,
+                                                            userCoil.Loop.DesignVolumeFlowRate);
             }
         }
 
-        state.dataUserDefinedComponents->UserCoil(CompNum).initialize(state);
+        userCoil.initialize(state);
 
-        if (state.dataUserDefinedComponents->UserCoil(CompNum).ErlSimProgramMngr > 0) {
+        if (userCoil.ErlSimProgramMngr > 0) {
             EMSManager::ManageEMS(state,
                                   EMSManager::EMSCallFrom::UserDefinedComponentModel,
                                   anyEMSRan,
-                                  state.dataUserDefinedComponents->UserCoil(CompNum).ErlSimProgramMngr);
-        } else if (state.dataUserDefinedComponents->UserCoil(CompNum).simPluginLocation > -1) {
+                                  userCoil.ErlSimProgramMngr);
+        } else if (userCoil.simPluginLocation > -1) {
             state.dataPluginManager->pluginManager->runSingleUserDefinedPlugin(state,
-                                                                               state.dataUserDefinedComponents->UserCoil(CompNum).simPluginLocation);
-        } else if (state.dataUserDefinedComponents->UserCoil(CompNum).simCallbackIndex > -1) {
+                                                                               userCoil.simPluginLocation);
+        } else if (userCoil.simCallbackIndex > -1) {
             state.dataPluginManager->pluginManager->runSingleUserDefinedCallback(state,
-                                                                                 state.dataUserDefinedComponents->UserCoil(CompNum).simCallbackIndex);
+                                                                                 userCoil.simCallbackIndex);
         }
 
-        state.dataUserDefinedComponents->UserCoil(CompNum).report(state);
+        userCoil.report(state);
 
         if (AirLoopNum != -1) { // IF the system is not an equipment of outdoor air unit
             // determine if heating or cooling on primary air stream
-            HeatingActive = state.dataLoopNodes->Node(state.dataUserDefinedComponents->UserCoil(CompNum).Air(1).InletNodeNum).Temp <
-                            state.dataLoopNodes->Node(state.dataUserDefinedComponents->UserCoil(CompNum).Air(1).OutletNodeNum).Temp;
+            HeatingActive = state.dataLoopNodes->Node(userCoil.Air(1).InletNodeNum).Temp <
+                            state.dataLoopNodes->Node(userCoil.Air(1).OutletNodeNum).Temp;
 
             Real64 EnthInlet =
-                Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(state.dataUserDefinedComponents->UserCoil(CompNum).Air(1).InletNodeNum).Temp,
-                                           state.dataLoopNodes->Node(state.dataUserDefinedComponents->UserCoil(CompNum).Air(1).InletNodeNum).HumRat);
+                Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(userCoil.Air(1).InletNodeNum).Temp,
+                                           state.dataLoopNodes->Node(userCoil.Air(1).InletNodeNum).HumRat);
             Real64 EnthOutlet =
-                Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(state.dataUserDefinedComponents->UserCoil(CompNum).Air(1).OutletNodeNum).Temp,
-                                           state.dataLoopNodes->Node(state.dataUserDefinedComponents->UserCoil(CompNum).Air(1).OutletNodeNum).HumRat);
+                Psychrometrics::PsyHFnTdbW(state.dataLoopNodes->Node(userCoil.Air(1).OutletNodeNum).Temp,
+                                           state.dataLoopNodes->Node(userCoil.Air(1).OutletNodeNum).HumRat);
             CoolingActive = EnthInlet > EnthOutlet;
         }
     }
@@ -2895,6 +2906,7 @@ namespace UserDefinedComponents {
         }
     }
 
+#ifdef OLD_API  
     void GetUserDefinedCoilIndex(
         EnergyPlusData &state, std::string const &CoilName, int &CoilIndex, bool &ErrorsFound, std::string const &CurrentModuleObject)
     {
@@ -3000,6 +3012,30 @@ namespace UserDefinedComponents {
             CoilAirOutletNode = state.dataUserDefinedComponents->UserCoil(CoilIndex).Air(1).OutletNodeNum;
         }
     }
+#endif // OLD_API
+  
+    int GetCoilIndex(EnergyPlusData &state, std::string const &CoilName)
+    {
+        if (state.dataUserDefinedComponents->GetInput) { // First time subroutine has been called, get input data
+            GetUserDefinedComponents(state);
+            state.dataUserDefinedComponents->GetInput = false; // Set logic flag to disallow getting the input data on future calls to this subroutine
+        }
+
+        return Util::FindItem(CoilName, state.dataUserDefinedComponents->UserCoil, state.dataUserDefinedComponents->NumUserCoils);
+    }
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataUserDefinedComponents->NumUserCoils);
+        return state.dataUserDefinedComponents->UserCoil(coilNum).Air(1).InletNodeNum;
+    }
+
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataUserDefinedComponents->NumUserCoils);
+        return state.dataUserDefinedComponents->UserCoil(coilNum).Air(1).OutletNodeNum;
+    }
+  
 
 } // namespace UserDefinedComponents
 
diff --git a/src/EnergyPlus/UserDefinedComponents.hh b/src/EnergyPlus/UserDefinedComponents.hh
index b265dad5668..51f70d82515 100644
--- a/src/EnergyPlus/UserDefinedComponents.hh
+++ b/src/EnergyPlus/UserDefinedComponents.hh
@@ -314,6 +314,12 @@ namespace UserDefinedComponents {
                             bool &HeatingActive,
                             bool &CoolingActive);
 
+    void SimCoilUserDefined(EnergyPlusData &state,
+                            int const coilNum,
+                            int AirLoopNum,
+                            bool &HeatingActive,
+                            bool &CoolingActive);
+  
     void SimZoneAirUserDefined(EnergyPlusData &state,
                                std::string_view CompName,      // name of the packaged terminal heat pump
                                int ZoneNum,                    // number of zone being served
@@ -329,15 +335,22 @@ namespace UserDefinedComponents {
 
     void GetUserDefinedComponents(EnergyPlusData &state);
 
+#ifdef OLD_API
     void GetUserDefinedCoilIndex(
         EnergyPlusData &state, std::string const &CoilName, int &CoilIndex, bool &ErrorsFound, std::string const &CurrentModuleObject);
 
-    void GetUserDefinedCoilAirInletNode(
+   void GetUserDefinedCoilAirInletNode(
         EnergyPlusData &state, std::string const &CoilName, int &CoilAirInletNode, bool &ErrorsFound, std::string const &CurrentModuleObject);
 
     void GetUserDefinedCoilAirOutletNode(
         EnergyPlusData &state, std::string const &CoilName, int &CoilAirOutletNode, bool &ErrorsFound, std::string const &CurrentModuleObject);
+#endif // OLD_API
+  
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum); 
 
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
 } // namespace UserDefinedComponents
 
 struct UserDefinedComponentsData : BaseGlobalStruct
diff --git a/src/EnergyPlus/UtilityRoutines.hh b/src/EnergyPlus/UtilityRoutines.hh
index 21b5fb9b28e..e2445093584 100644
--- a/src/EnergyPlus/UtilityRoutines.hh
+++ b/src/EnergyPlus/UtilityRoutines.hh
@@ -296,6 +296,7 @@ void ShowSevereInvalidKey(
 void ShowSevereInvalidBool(EnergyPlusData &state, ErrorObjectHeader const &eoh, std::string_view fieldName, std::string_view fieldValue);
 
 void ShowSevereCustom(EnergyPlusData &state, ErrorObjectHeader const &eoh, std::string_view msg);
+
 void ShowSevereCustomField(
     EnergyPlusData &state, ErrorObjectHeader const &eoh, std::string_view fieldName, std::string_view fieldValue, std::string_view msg);
 
diff --git a/src/EnergyPlus/VariableSpeedCoils.cc b/src/EnergyPlus/VariableSpeedCoils.cc
index c70c9434b5c..1161bf3a2f1 100644
--- a/src/EnergyPlus/VariableSpeedCoils.cc
+++ b/src/EnergyPlus/VariableSpeedCoils.cc
@@ -122,18 +122,8 @@ namespace VariableSpeedCoils {
                                const Real64 OnOffAirFlowRatio // ratio of comp on to comp off air flow rate
     )
     {
-
-        //       AUTHOR         Bo Shen, ORNL
-        //       DATE WRITTEN   March 2012
-        //       MODIFIED       Bo Shen, 12/2014, add variable-speed HPWH
-
-        // PURPOSE OF THIS SUBROUTINE:
-        // This subroutine manages variable-speed Water to Air Heat Pump component simulation.
-
-        // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         int DXCoilNum; // The WatertoAirHP that you are currently loading input into
-        int SpeedCal;  // variable for error proof speed input
-
+        
         // Obtains and Allocates WatertoAirHP related parameters from input file
         if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
             GetVarSpeedCoilInput(state);
@@ -165,6 +155,45 @@ namespace VariableSpeedCoils {
             }
         }
 
+        SimVariableSpeedCoils(state,
+                              DXCoilNum,
+                              fanOp,
+                              compressorOp,
+                              PartLoadFrac,
+                              SpeedNum,
+                              SpeedRatio,
+                              SensLoad,
+                              LatentLoad,
+                              OnOffAirFlowRatio);
+        
+    }
+  
+    void SimVariableSpeedCoils(EnergyPlusData &state,
+                               int const coilNum,
+                               HVAC::FanOp const fanOp,               // Continuous fan OR cycling compressor
+                               HVAC::CompressorOp const compressorOp, // compressor on/off. 0 = off; 1= on
+                               Real64 const PartLoadFrac,
+                               int const SpeedNum,            // compressor speed number
+                               Real64 const SpeedRatio,       // compressor speed ratio
+                               Real64 const SensLoad,         // Sensible demand load [W]
+                               Real64 const LatentLoad,       // Latent demand load [W]
+                               const Real64 OnOffAirFlowRatio // ratio of comp on to comp off air flow rate
+    )
+    {
+
+        //       AUTHOR         Bo Shen, ORNL
+        //       DATE WRITTEN   March 2012
+        //       MODIFIED       Bo Shen, 12/2014, add variable-speed HPWH
+
+        // PURPOSE OF THIS SUBROUTINE:
+        // This subroutine manages variable-speed Water to Air Heat Pump component simulation.
+
+        // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
+        int SpeedCal;  // variable for error proof speed input
+
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(coilNum);
+
         // ERROR PROOF
         if (SpeedNum < 1) {
             SpeedCal = 1;
@@ -172,31 +201,31 @@ namespace VariableSpeedCoils {
             SpeedCal = SpeedNum;
         }
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
+        if ((vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) ||
+            (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed)) {
             // Cooling mode
-            InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
+            InitVarSpeedCoil(state, coilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
             CalcVarSpeedCoilCooling(
-                state, DXCoilNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
-            UpdateVarSpeedCoil(state, DXCoilNum);
-        } else if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
-                   (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
+                state, coilNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
+            UpdateVarSpeedCoil(state, coilNum);
+        } else if ((vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) ||
+                   (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed)) {
             // Heating mode
-            InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
-            CalcVarSpeedCoilHeating(state, DXCoilNum, fanOp, SensLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
-            UpdateVarSpeedCoil(state, DXCoilNum);
-        } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
+            InitVarSpeedCoil(state, coilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
+            CalcVarSpeedCoilHeating(state, coilNum, fanOp, SensLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
+            UpdateVarSpeedCoil(state, coilNum);
+        } else if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
             // Heating mode
-            InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
-            CalcVarSpeedHPWH(state, DXCoilNum, PartLoadFrac, SpeedRatio, SpeedNum, fanOp);
-            UpdateVarSpeedCoil(state, DXCoilNum);
+            InitVarSpeedCoil(state, coilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
+            CalcVarSpeedHPWH(state, coilNum, PartLoadFrac, SpeedRatio, SpeedNum, fanOp);
+            UpdateVarSpeedCoil(state, coilNum);
         } else {
             ShowFatalError(state, "SimVariableSpeedCoils: WatertoAir heatpump not in either HEATING or COOLING mode");
         }
 
         // two additional output variables
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport = SpeedCal;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport = SpeedRatio;
+        vsCoil.SpeedNumReport = SpeedCal;
+        vsCoil.SpeedRatioReport = SpeedRatio;
     }
 
     void GetVarSpeedCoilInput(EnergyPlusData &state)
@@ -312,28 +341,29 @@ namespace VariableSpeedCoils {
             // ErrorsFound will be set to True if problem was found, left untouched otherwise
             GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
-            state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name;
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+            
+            vsCoil.bIsDesuperheater = false;
+            vsCoil.Name = AlphArray(1);
+            vsCoil.CoolHeatType = "COOLING";
+            vsCoil.coilType = HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit;
+            vsCoil.NumOfSpeeds = int(NumArray(1));
+            vsCoil.NormSpedLevel = int(NumArray(2));
+            vsCoil.RatedCapCoolTotal = NumArray(3);
+            vsCoil.RatedAirVolFlowRate = NumArray(4);
+            vsCoil.RatedWaterVolFlowRate = NumArray(5);
+            vsCoil.Twet_Rated = NumArray(6);
+            vsCoil.Gamma_Rated = NumArray(7);
+            vsCoil.MaxONOFFCyclesperHour = NumArray(8);
+            vsCoil.LatentCapacityTimeConstant = NumArray(9);
+            vsCoil.FanDelayTime = NumArray(10);
+            vsCoil.HOTGASREHEATFLG = int(NumArray(11));
+            vsCoil.CondenserType = DataHeatBalance::RefrigCondenserType::Water;
+
+            state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = vsCoil.Name;
             state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).SourceType = CurrentModuleObject;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "COOLING";
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
-                HVAC::cAllCoilTypes(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal = NumArray(3);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(5);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated = NumArray(6);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated = NumArray(7);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = NumArray(8);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = NumArray(9);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = NumArray(10);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HOTGASREHEATFLG = int(NumArray(11));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Water;
-
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
+
+            vsCoil.WaterInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(2),
                                   ErrorsFound,
@@ -343,7 +373,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Inlet,
                                   NodeInputManager::CompFluidStream::Secondary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
+            vsCoil.WaterOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(3),
                                   ErrorsFound,
@@ -353,7 +383,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Outlet,
                                   NodeInputManager::CompFluidStream::Secondary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
+            vsCoil.AirInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(4),
                                   ErrorsFound,
@@ -363,7 +393,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Inlet,
                                   NodeInputManager::CompFluidStream::Primary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
+            vsCoil.AirOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(5),
                                   ErrorsFound,
@@ -378,105 +408,99 @@ namespace VariableSpeedCoils {
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(4), AlphArray(5), "Air Nodes");
 
             //   If (VarSpeedCoil(DXCoilNum)%NumOfSpeeds .LT. 2) Then
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
+            if (vsCoil.NumOfSpeeds < 1) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
                 ErrorsFound = true;
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+            if (vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) {
+                vsCoil.NormSpedLevel = vsCoil.NumOfSpeeds;
             }
 
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
+            if ((vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) || (vsCoil.NormSpedLevel <= 0)) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
                 ErrorsFound = true;
             }
 
             // part load curve
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
+            vsCoil.PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
+            if (vsCoil.PLFFPLR == 0) {
                 if (lAlphaBlanks(6)) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...required {} is blank.", cAlphaFields(6)));
                 } else {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(6), AlphArray(6)));
                 }
                 ErrorsFound = true;
             } else {
-                CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
+                CurveVal = Curve::CurveValue(state, vsCoil.PLFFPLR, 1.0);
                 if (CurveVal > 1.10 || CurveVal < 0.90) {
                     ShowWarningError(state,
                                      format("{}{}=\"{}\", curve values",
                                             RoutineName,
                                             CurrentModuleObject,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                            vsCoil.Name));
                     ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(6)));
                     ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
                 }
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(13 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(14 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(I) = NumArray(17 + (I - 1) * 6);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
+                vsCoil.MSRatedSHR(I) = NumArray(13 + (I - 1) * 6);
+                vsCoil.MSRatedCOP(I) = NumArray(14 + (I - 1) * 6);
+                vsCoil.MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
+                vsCoil.MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
+                vsCoil.MSWasteHeatFrac(I) = NumArray(17 + (I - 1) * 6);
 
                 AlfaFieldIncre = 7 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
+                vsCoil.MSCCapFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
+                                                         vsCoil.MSCCapFTemp(I), // Curve index
                                                          {2},                                                                  // Valid dimensions
                                                          RoutineName,                                                          // Routine name
                                                          CurrentModuleObject,                                                  // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,           // Object Name
+                                                         vsCoil.Name,           // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                        // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -485,43 +509,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 8 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
+                vsCoil.MSCCapAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
+                                                         vsCoil.MSCCapAirFFlow(I), // Curve index
                                                          {1},                                                                     // Valid dimensions
                                                          RoutineName,                                                             // Routine name
                                                          CurrentModuleObject,                                                     // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,              // Object Name
+                                                         vsCoil.Name,              // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                           // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -530,43 +553,43 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 9 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
+                vsCoil.MSCCapWaterFFlow(I) =
                     Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) == 0) {
+                if (vsCoil.MSCCapWaterFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
+                                                         vsCoil.MSCCapWaterFFlow(I), // Curve index
                                                          {1},                                                        // Valid dimensions
                                                          RoutineName,                                                // Routine name
                                                          CurrentModuleObject,                                        // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
+                                                         vsCoil.Name, // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                              // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -575,44 +598,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 10 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
+                vsCoil.MSEIRFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
+                                                         vsCoil.MSEIRFTemp(I), // Curve index
                                                          {2},                                                                 // Valid dimensions
                                                          RoutineName,                                                         // Routine name
                                                          CurrentModuleObject,                                                 // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,          // Object Name
+                                                         vsCoil.Name,          // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                       // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -621,43 +642,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 11 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
+                vsCoil.MSEIRAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
+                                                         vsCoil.MSEIRAirFFlow(I), // Curve index
                                                          {1},                                                                    // Valid dimensions
                                                          RoutineName,                                                            // Routine name
                                                          CurrentModuleObject,                                                    // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,             // Object Name
+                                                         vsCoil.Name,             // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                          // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -666,43 +686,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 12 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) == 0) {
+                vsCoil.MSEIRWaterFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRWaterFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
+                                                         vsCoil.MSEIRWaterFFlow(I), // Curve index
                                                          {1},                                                                      // Valid dimensions
                                                          RoutineName,                                                              // Routine name
                                                          CurrentModuleObject,                                                      // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,               // Object Name
+                                                         vsCoil.Name,               // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                            // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -712,44 +731,42 @@ namespace VariableSpeedCoils {
 
                 AlfaFieldIncre = 13 + (I - 1) * 7;
                 // Read waste heat modifier curve name
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) == 0) {
+                vsCoil.MSWasteHeat(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSWasteHeat(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal types are BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), // Curve index
+                                                         vsCoil.MSWasteHeat(I), // Curve index
                                                          {2},                                                                  // Valid dimensions
                                                          RoutineName,                                                          // Routine name
                                                          CurrentModuleObject,                                                  // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,           // Object Name
+                                                         vsCoil.Name,           // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                        // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), RatedInletWaterTemp, RatedInletAirTemp);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSWasteHeat(I), RatedInletWaterTemp, RatedInletAirTemp);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -758,66 +775,59 @@ namespace VariableSpeedCoils {
                 }
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedPercentTotCap(I) = vsCoil.MSRatedTotCap(I) / vsCoil.MSRatedTotCap(vsCoil.NumOfSpeeds);
+                vsCoil.MSRatedAirVolFlowPerRatedTotCap(I) = vsCoil.MSRatedAirVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
+                vsCoil.MSRatedWaterVolFlowPerRatedTotCap(I) = vsCoil.MSRatedWaterVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
             }
 
             // CurrentModuleObject = "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit"
             SetupOutputVariable(state,
                                 "Cooling Coil Electricity Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
+                                vsCoil.Energy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::Electricity,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::Cooling);
             SetupOutputVariable(state,
                                 "Cooling Coil Total Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
+                                vsCoil.EnergyLoadTotal,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::EnergyTransfer,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::CoolingCoils);
             SetupOutputVariable(state,
                                 "Cooling Coil Sensible Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
+                                vsCoil.EnergySensible,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
             SetupOutputVariable(state,
                                 "Cooling Coil Latent Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
+                                vsCoil.EnergyLatent,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
             SetupOutputVariable(state,
                                 "Cooling Coil Source Side Heat Transfer Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
+                                vsCoil.EnergySource,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::PlantLoopCoolingDemand,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::CoolingCoils);
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolSens =
+            vsCoil.RatedCapCoolSens =
                 DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
         }
 
@@ -848,25 +858,27 @@ namespace VariableSpeedCoils {
             // ErrorsFound will be set to True if problem was found, left untouched otherwise
             GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+            
+            vsCoil.bIsDesuperheater = false;
+            vsCoil.Name = AlphArray(1);
             // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
-            state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name;
+
+            state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = vsCoil.Name;
             state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).SourceType = CurrentModuleObject;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "COOLING";
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_CoolingAirToAirVariableSpeed;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingAirToAirVariableSpeed);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal = NumArray(3);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated = NumArray(5);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated = NumArray(6);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = NumArray(7);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = NumArray(8);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = NumArray(9);
-
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
+            vsCoil.CoolHeatType = "COOLING";
+            vsCoil.coilType = HVAC::CoilType::CoolingDXVariableSpeed;
+            vsCoil.NumOfSpeeds = int(NumArray(1));
+            vsCoil.NormSpedLevel = int(NumArray(2));
+            vsCoil.RatedCapCoolTotal = NumArray(3);
+            vsCoil.RatedAirVolFlowRate = NumArray(4);
+            vsCoil.Twet_Rated = NumArray(5);
+            vsCoil.Gamma_Rated = NumArray(6);
+            vsCoil.MaxONOFFCyclesperHour = NumArray(7);
+            vsCoil.LatentCapacityTimeConstant = NumArray(8);
+            vsCoil.FanDelayTime = NumArray(9);
+
+            vsCoil.AirInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(2),
                                   ErrorsFound,
@@ -876,7 +888,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Inlet,
                                   NodeInputManager::CompFluidStream::Primary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
+            vsCoil.AirOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(3),
                                   ErrorsFound,
@@ -889,53 +901,49 @@ namespace VariableSpeedCoils {
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Air Nodes");
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
+            if (vsCoil.NumOfSpeeds < 1) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
                 ErrorsFound = true;
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+            if (vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) {
+                vsCoil.NormSpedLevel = vsCoil.NumOfSpeeds;
             }
 
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
+            if ((vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) || (vsCoil.NormSpedLevel <= 0)) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
                 ErrorsFound = true;
             }
 
             // part load curve
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
+            vsCoil.PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
+            if (vsCoil.PLFFPLR == 0) {
                 if (lAlphaBlanks(4)) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...required {} is blank.", cAlphaFields(6)));
                 } else {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(4), AlphArray(4)));
                 }
                 ErrorsFound = true;
             } else {
-                CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
+                CurveVal = Curve::CurveValue(state, vsCoil.PLFFPLR, 1.0);
                 if (CurveVal > 1.10 || CurveVal < 0.90) {
                     ShowWarningError(state,
                                      format("{}{}=\"{}\", curve values",
                                             RoutineName,
                                             CurrentModuleObject,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                            vsCoil.Name));
                     ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(4)));
                     ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
                 }
@@ -943,25 +951,25 @@ namespace VariableSpeedCoils {
 
             // outdoor condenser node
             if (lAlphaBlanks(5)) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum = 0;
+                vsCoil.CondenserInletNodeNum = 0;
             } else {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum =
+                vsCoil.CondenserInletNodeNum =
                     GetOnlySingleNode(state,
                                       AlphArray(5),
                                       ErrorsFound,
                                       DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed,
-                                      state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                      vsCoil.Name,
                                       DataLoopNode::NodeFluidType::Air,
                                       DataLoopNode::ConnectionType::OutsideAirReference,
                                       NodeInputManager::CompFluidStream::Primary,
                                       DataLoopNode::ObjectIsNotParent);
 
-                if (!OutAirNodeManager::CheckOutAirNodeNumber(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum)) {
+                if (!OutAirNodeManager::CheckOutAirNodeNumber(state, vsCoil.CondenserInletNodeNum)) {
                     ShowWarningError(state,
                                      format("{}{}=\"{}\", may be invalid",
                                             RoutineName,
                                             CurrentModuleObject,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                            vsCoil.Name));
                     ShowContinueError(state,
                                       format("{}=\"{}\", node does not appear in an OutdoorAir:NodeList or as an OutdoorAir:Node.",
                                              cAlphaFields(10),
@@ -972,26 +980,26 @@ namespace VariableSpeedCoils {
             }
 
             if ((Util::SameString(AlphArray(6), "AirCooled")) || lAlphaBlanks(6)) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Air;
+                vsCoil.CondenserType = DataHeatBalance::RefrigCondenserType::Air;
             } else if (Util::SameString(AlphArray(6), "EvaporativelyCooled")) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Evap;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ReportEvapCondVars = true;
+                vsCoil.CondenserType = DataHeatBalance::RefrigCondenserType::Evap;
+                vsCoil.ReportEvapCondVars = true;
             } else {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{}=\"{}\":", cAlphaFields(6), AlphArray(6)));
                 ShowContinueError(state, "...must be AirCooled or EvaporativelyCooled.");
                 ErrorsFound = true;
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower = NumArray(10);
+            vsCoil.EvapCondPumpElecNomPower = NumArray(10);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower != DataSizing::AutoSize) {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower < 0.0) {
+            if (vsCoil.EvapCondPumpElecNomPower != DataSizing::AutoSize) {
+                if (vsCoil.EvapCondPumpElecNomPower < 0.0) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...{} cannot be < 0.0.", cNumericFields(10)));
                     ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(10)));
                     ErrorsFound = true;
@@ -999,95 +1007,88 @@ namespace VariableSpeedCoils {
             }
 
             // Set crankcase heater capacity
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(11);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
+            vsCoil.CrankcaseHeaterCapacity = NumArray(11);
+            if (vsCoil.CrankcaseHeaterCapacity < 0.0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} cannot be < 0.0.", cNumericFields(11)));
                 ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(11)));
                 ErrorsFound = true;
             }
 
             // Set crankcase heater cutout temperature
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(12);
+            vsCoil.MaxOATCrankcaseHeater = NumArray(12);
 
             // Set crankcase heater cutout temperature
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor = NumArray(13);
+            vsCoil.MinOATCompressor = NumArray(13);
 
             // A7; \field Crankcase Heater Capacity Function of Outdoor Temperature Curve Name
-            if (!lAlphaBlanks(7)) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(7));
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex == 0) { // can't find the curve
-                    ShowSevereError(state,
-                                    format("{} = {}:  {} not found = {}",
-                                           CurrentModuleObject,
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                                           cAlphaFields(7),
-                                           AlphArray(7)));
-                    ErrorsFound = true;
-                } else {
-                    ErrorsFound |=
-                        Curve::CheckCurveDims(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
-                                              {1},                                                        // Valid dimensions
-                                              RoutineName,                                                // Routine name
-                                              CurrentModuleObject,                                        // Object Type
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
-                                              cAlphaFields(7));                                           // Field Name
-                }
+            if (lAlphaBlanks(7)) {
+            } else if ((vsCoil.CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(7))) == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(7), AlphArray(7));
+                ErrorsFound = true;
+            } else {
+                ErrorsFound |=
+                    Curve::CheckCurveDims(state,
+                                          vsCoil.CrankcaseHeaterCapacityCurveIndex, // Curve index
+                                          {1},                                      // Valid dimensions
+                                          RoutineName,                              // Routine name
+                                          CurrentModuleObject,                      // Object Type
+                                          vsCoil.Name,                              // Object Name
+                                          cAlphaFields(7));                         // Field Name
             }
 
             // Get Water System tank connections
             //  A8, \field Name of Water Storage Tank for Supply
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyName = AlphArray(8);
+            vsCoil.EvapWaterSupplyName = AlphArray(8);
             if (lAlphaBlanks(8)) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyMode = WaterSupplyFromMains;
+                vsCoil.EvapWaterSupplyMode = WaterSupplyFromMains;
             } else {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyMode = WaterSupplyFromTank;
+                vsCoil.EvapWaterSupplyMode = WaterSupplyFromTank;
                 WaterManager::SetupTankDemandComponent(state,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                                       vsCoil.Name,
                                                        CurrentModuleObject,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyName,
+                                                       vsCoil.EvapWaterSupplyName,
                                                        ErrorsFound,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupTankID,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterTankDemandARRID);
+                                                       vsCoil.EvapWaterSupTankID,
+                                                       vsCoil.EvapWaterTankDemandARRID);
             }
 
             // A9; \field Name of Water Storage Tank for Condensate Collection
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectName = AlphArray(9);
+            vsCoil.CondensateCollectName = AlphArray(9);
             if (lAlphaBlanks(9)) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode = CondensateDiscarded;
+                vsCoil.CondensateCollectMode = CondensateDiscarded;
             } else {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode = CondensateToTank;
+                vsCoil.CondensateCollectMode = CondensateToTank;
                 WaterManager::SetupTankSupplyComponent(state,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                                       vsCoil.Name,
                                                        CurrentModuleObject,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectName,
+                                                       vsCoil.CondensateCollectName,
                                                        ErrorsFound,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateTankID,
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateTankSupplyARRID);
+                                                       vsCoil.CondensateTankID,
+                                                       vsCoil.CondensateTankSupplyARRID);
             }
 
             //   Basin heater power as a function of temperature must be greater than or equal to 0
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff = NumArray(14);
+            vsCoil.BasinHeaterPowerFTempDiff = NumArray(14);
             if (NumArray(14) < 0.0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 0.0.", cNumericFields(14)));
                 ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(14)));
                 ErrorsFound = true;
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp = NumArray(15);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff > 0.0) {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp < 2.0) {
+            vsCoil.BasinHeaterSetPointTemp = NumArray(15);
+            if (vsCoil.BasinHeaterPowerFTempDiff > 0.0) {
+                if (vsCoil.BasinHeaterSetPointTemp < 2.0) {
                     ShowWarningError(state,
                                      format("{}{}=\"{}\", freeze possible",
                                             RoutineName,
                                             CurrentModuleObject,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                            vsCoil.Name));
                     ShowContinueError(state, format("...{} is < 2 {{C}}. Freezing could occur.", cNumericFields(15)));
                     ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(15)));
                 }
@@ -1095,70 +1096,66 @@ namespace VariableSpeedCoils {
 
             if (lAlphaBlanks(10)) {
                 // Should this be ScheduleAlwaysOff?
-            } else if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).basinHeaterSched = Sched::GetSchedule(state, AlphArray(10))) ==
-                       nullptr) {
+            } else if ((vsCoil.basinHeaterSched = Sched::GetSchedule(state, AlphArray(10))) == nullptr) {
                 ShowWarningItemNotFound(
                     state, eoh, cAlphaFields(10), AlphArray(10), "Basin heater will be available to operate throughout the simulation.");
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(16 + (I - 1) * 8);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(17 + (I - 1) * 8);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(18 + (I - 1) * 8);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(19 + (I - 1) * 8);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(20 + (I - 1) * 8);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(21 + (I - 1) * 8);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(I) = NumArray(22 + (I - 1) * 8);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) = NumArray(23 + (I - 1) * 8);
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) < 0.0 ||
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) > 1.0) {
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedTotCap(I) = NumArray(16 + (I - 1) * 8);
+                vsCoil.MSRatedSHR(I) = NumArray(17 + (I - 1) * 8);
+                vsCoil.MSRatedCOP(I) = NumArray(18 + (I - 1) * 8);
+                vsCoil.MSRatedAirVolFlowRate(I) = NumArray(19 + (I - 1) * 8);
+                vsCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(20 + (I - 1) * 8);
+                vsCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(21 + (I - 1) * 8);
+                vsCoil.EvapCondAirFlow(I) = NumArray(22 + (I - 1) * 8);
+                vsCoil.EvapCondEffect(I) = NumArray(23 + (I - 1) * 8);
+                if (vsCoil.EvapCondEffect(I) < 0.0 || vsCoil.EvapCondEffect(I) > 1.0) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...{} cannot be < 0.0 or > 1.0.", cNumericFields(23 + (I - 1) * 8)));
                     ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(23 + (I - 1) * 8)));
                     ErrorsFound = true;
                 }
 
                 AlfaFieldIncre = 11 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
+                vsCoil.MSCCapFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
+                                                         vsCoil.MSCCapFTemp(I), // Curve index
                                                          {2},                                                                  // Valid dimensions
                                                          RoutineName,                                                          // Routine name
                                                          CurrentModuleObject,                                                  // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,           // Object Name
+                                                         vsCoil.Name,           // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                        // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1167,43 +1164,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 12 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
+                vsCoil.MSCCapAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
+                                                         vsCoil.MSCCapAirFFlow(I), // Curve index
                                                          {1},                                                                     // Valid dimensions
                                                          RoutineName,                                                             // Routine name
                                                          CurrentModuleObject,                                                     // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,              // Object Name
+                                                         vsCoil.Name,              // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                           // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1212,44 +1208,43 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 13 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
+                vsCoil.MSEIRFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
+                                                         vsCoil.MSEIRFTemp(I), // Curve index
                                                          {2},                                                                 // Valid dimensions
                                                          RoutineName,                                                         // Routine name
                                                          CurrentModuleObject,                                                 // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,          // Object Name
+                                                         vsCoil.Name,          // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                       // Field Name
 
                     if (!ErrorsFound) {
                         CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
+                            state, vsCoil.MSEIRFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1258,43 +1253,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 14 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
+                vsCoil.MSEIRAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
+                                                         vsCoil.MSEIRAirFFlow(I), // Curve index
                                                          {1},                                                                    // Valid dimensions
                                                          RoutineName,                                                            // Routine name
                                                          CurrentModuleObject,                                                    // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,             // Object Name
+                                                         vsCoil.Name,             // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                          // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1303,63 +1297,56 @@ namespace VariableSpeedCoils {
                 }
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvapCondVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedPercentTotCap(I) = vsCoil.MSRatedTotCap(I) / vsCoil.MSRatedTotCap(vsCoil.NumOfSpeeds);
+                vsCoil.MSRatedAirVolFlowPerRatedTotCap(I) = vsCoil.MSRatedAirVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
+                vsCoil.MSRatedEvapCondVolFlowPerRatedTotCap(I) = vsCoil.EvapCondAirFlow(I) / vsCoil.MSRatedTotCap(I);
             }
 
             // CurrentModuleObject = "Coil:Cooling:DX:VariableSpeed"
             SetupOutputVariable(state,
                                 "Cooling Coil Electricity Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
+                                vsCoil.Energy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::Electricity,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::Cooling);
             SetupOutputVariable(state,
                                 "Cooling Coil Total Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
+                                vsCoil.EnergyLoadTotal,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::EnergyTransfer,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::CoolingCoils);
             SetupOutputVariable(state,
                                 "Cooling Coil Sensible Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
+                                vsCoil.EnergySensible,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
             SetupOutputVariable(state,
                                 "Cooling Coil Latent Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
+                                vsCoil.EnergyLatent,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
             SetupOutputVariable(state,
                                 "Cooling Coil Source Side Heat Transfer Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
+                                vsCoil.EnergySource,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolSens =
+            vsCoil.RatedCapCoolSens =
                 DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
         }
 
@@ -1387,26 +1374,26 @@ namespace VariableSpeedCoils {
             // ErrorsFound will be set to True if problem was found, left untouched otherwise
             GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "HEATING";
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_HeatingWaterToAirHPVSEquationFit; // fix coil type
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+
+            vsCoil.bIsDesuperheater = false;
+            vsCoil.Name = AlphArray(1);
+            vsCoil.CoolHeatType = "HEATING";
+            vsCoil.coilType = HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit; // fix coil type
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
-                HVAC::cAllCoilTypes(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat = NumArray(3);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(5);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Water;
+            vsCoil.NumOfSpeeds = int(NumArray(1));
+            vsCoil.NormSpedLevel = int(NumArray(2));
+            vsCoil.RatedCapHeat = NumArray(3);
+            vsCoil.RatedAirVolFlowRate = NumArray(4);
+            vsCoil.RatedWaterVolFlowRate = NumArray(5);
+            vsCoil.CondenserType = DataHeatBalance::RefrigCondenserType::Water;
 
             // Previously set by parent objects, but not user-definable
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = 4;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = 0.;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = 0.;
+            vsCoil.MaxONOFFCyclesperHour = 4;
+            vsCoil.LatentCapacityTimeConstant = 0.;
+            vsCoil.FanDelayTime = 0.;
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
+            vsCoil.WaterInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(2),
                                   ErrorsFound,
@@ -1416,7 +1403,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Inlet,
                                   NodeInputManager::CompFluidStream::Secondary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
+            vsCoil.WaterOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(3),
                                   ErrorsFound,
@@ -1426,7 +1413,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Outlet,
                                   NodeInputManager::CompFluidStream::Secondary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
+            vsCoil.AirInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(4),
                                   ErrorsFound,
@@ -1436,7 +1423,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Inlet,
                                   NodeInputManager::CompFluidStream::Primary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
+            vsCoil.AirOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(5),
                                   ErrorsFound,
@@ -1451,98 +1438,93 @@ namespace VariableSpeedCoils {
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(4), AlphArray(5), "Air Nodes");
 
             //       If (VarSpeedCoil(DXCoilNum)%NumOfSpeeds .LT. 2) Then
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
+            if (vsCoil.NumOfSpeeds < 1) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
                 ErrorsFound = true;
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+            if (vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) {
+                vsCoil.NormSpedLevel = vsCoil.NumOfSpeeds;
             }
 
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
+            if ((vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) || (vsCoil.NormSpedLevel <= 0)) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
                 ErrorsFound = true;
             }
 
             // part load curve
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
+            vsCoil.PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
+            if (vsCoil.PLFFPLR == 0) {
                 if (lAlphaBlanks(6)) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...required {} is blank.", cAlphaFields(6)));
                 } else {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(6), AlphArray(6)));
                 }
                 ErrorsFound = true;
             } else {
-                CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
+                CurveVal = Curve::CurveValue(state, vsCoil.PLFFPLR, 1.0);
                 if (CurveVal > 1.10 || CurveVal < 0.90) {
                     ShowWarningError(state,
                                      format("{}{}=\"{}\", curve values",
                                             RoutineName,
                                             CurrentModuleObject,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                            vsCoil.Name));
                     ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(6)));
                     ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
                 }
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(6 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(7 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(8 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(9 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(I) = NumArray(10 + (I - 1) * 5);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedTotCap(I) = NumArray(6 + (I - 1) * 5);
+                vsCoil.MSRatedCOP(I) = NumArray(7 + (I - 1) * 5);
+                vsCoil.MSRatedAirVolFlowRate(I) = NumArray(8 + (I - 1) * 5);
+                vsCoil.MSRatedWaterVolFlowRate(I) = NumArray(9 + (I - 1) * 5);
+                vsCoil.MSWasteHeatFrac(I) = NumArray(10 + (I - 1) * 5);
 
                 AlfaFieldIncre = 7 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
+                vsCoil.MSCCapFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
+                                                         vsCoil.MSCCapFTemp(I), // Curve index
                                                          {2},                                                                  // Valid dimensions
                                                          RoutineName,                                                          // Routine name
                                                          CurrentModuleObject,                                                  // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,           // Object Name
+                                                         vsCoil.Name,           // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                        // Field Name
 
                     if (!ErrorsFound) {
                         CurveVal = Curve::CurveValue(state,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I),
+                                                     vsCoil.MSCCapFTemp(I),
                                                      RatedInletAirTempHeat,
                                                      RatedInletWaterTempHeat);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
@@ -1550,7 +1532,7 @@ namespace VariableSpeedCoils {
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1559,43 +1541,43 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 8 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
+                vsCoil.MSCCapAirFFlow(I) =
                     Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
+                if (vsCoil.MSCCapAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
+                                                         vsCoil.MSCCapAirFFlow(I), // Curve index
                                                          {1},                                                                     // Valid dimensions
                                                          RoutineName,                                                             // Routine name
                                                          CurrentModuleObject,                                                     // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,              // Object Name
+                                                         vsCoil.Name,              // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                           // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1604,43 +1586,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 9 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) == 0) {
+                vsCoil.MSCCapWaterFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapWaterFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
+                                                         vsCoil.MSCCapWaterFFlow(I), // Curve index
                                                          {1},                                                        // Valid dimensions
                                                          RoutineName,                                                // Routine name
                                                          CurrentModuleObject,                                        // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
+                                                         vsCoil.Name, // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                              // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1649,38 +1630,37 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 10 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
+                vsCoil.MSEIRFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
+                                                         vsCoil.MSEIRFTemp(I), // Curve index
                                                          {2},                                                                 // Valid dimensions
                                                          RoutineName,                                                         // Routine name
                                                          CurrentModuleObject,                                                 // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,          // Object Name
+                                                         vsCoil.Name,          // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                       // Field Name
 
                     if (!ErrorsFound) {
                         CurveVal = Curve::CurveValue(state,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I),
+                                                     vsCoil.MSEIRFTemp(I),
                                                      RatedInletAirTempHeat,
                                                      RatedInletWaterTempHeat);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
@@ -1688,7 +1668,7 @@ namespace VariableSpeedCoils {
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1697,43 +1677,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 11 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
+                vsCoil.MSEIRAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
+                                                         vsCoil.MSEIRAirFFlow(I), // Curve index
                                                          {1},                                                                    // Valid dimensions
                                                          RoutineName,                                                            // Routine name
                                                          CurrentModuleObject,                                                    // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,             // Object Name
+                                                         vsCoil.Name,             // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                          // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1742,43 +1721,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 12 + (I - 1) * 7;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) == 0) {
+                vsCoil.MSEIRWaterFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRWaterFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
+                                                         vsCoil.MSEIRWaterFFlow(I), // Curve index
                                                          {1},                                                                      // Valid dimensions
                                                          RoutineName,                                                              // Routine name
                                                          CurrentModuleObject,                                                      // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,               // Object Name
+                                                         vsCoil.Name,               // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                            // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1788,38 +1766,37 @@ namespace VariableSpeedCoils {
 
                 AlfaFieldIncre = 13 + (I - 1) * 7;
                 // Read waste heat modifier curve name
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) == 0) {
+                vsCoil.MSWasteHeat(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSWasteHeat(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal types are BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), // Curve index
+                                                         vsCoil.MSWasteHeat(I), // Curve index
                                                          {2},                                                                  // Valid dimensions
                                                          RoutineName,                                                          // Routine name
                                                          CurrentModuleObject,                                                  // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,           // Object Name
+                                                         vsCoil.Name,           // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                        // Field Name
 
                     if (!ErrorsFound) {
                         CurveVal = Curve::CurveValue(state,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I),
+                                                     vsCoil.MSWasteHeat(I),
                                                      RatedInletAirTempHeat,
                                                      RatedInletWaterTempHeat);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
@@ -1827,7 +1804,7 @@ namespace VariableSpeedCoils {
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -1836,63 +1813,56 @@ namespace VariableSpeedCoils {
                 }
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedPercentTotCap(I) = vsCoil.MSRatedTotCap(I) / vsCoil.MSRatedTotCap(vsCoil.NumOfSpeeds);
+                vsCoil.MSRatedAirVolFlowPerRatedTotCap(I) = vsCoil.MSRatedAirVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
+                vsCoil.MSRatedWaterVolFlowPerRatedTotCap(I) = vsCoil.MSRatedWaterVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
             }
 
             // CurrentModuleObject = "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit"
             SetupOutputVariable(state,
                                 "Heating Coil Electricity Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
+                                vsCoil.Energy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::Electricity,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::Heating);
             SetupOutputVariable(state,
                                 "Heating Coil Heating Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
+                                vsCoil.EnergyLoadTotal,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::EnergyTransfer,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::HeatingCoils);
             SetupOutputVariable(state,
                                 "Heating Coil Source Side Heat Transfer Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
+                                vsCoil.EnergySource,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::PlantLoopHeatingDemand,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::HeatingCoils);
 
             // create predefined report entries
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilType, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, CurrentModuleObject);
+                state, state.dataOutRptPredefined->pdchHeatCoilType, vsCoil.Name, CurrentModuleObject);
             OutputReportPredefined::PreDefTableEntry(state,
                                                      state.dataOutRptPredefined->pdchHeatCoilNomCap,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat);
+                                                     vsCoil.Name,
+                                                     vsCoil.RatedCapHeat);
             OutputReportPredefined::PreDefTableEntry(state,
                                                      state.dataOutRptPredefined->pdchHeatCoilNomEff,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel));
+                                                     vsCoil.Name,
+                                                     vsCoil.MSRatedCOP(
+                                                         vsCoil.NormSpedLevel));
         }
 
         //-------------------------AIR SOURCE, HEATING---BEGIN
@@ -1915,25 +1885,28 @@ namespace VariableSpeedCoils {
                                                                      lAlphaBlanks,
                                                                      cAlphaFields,
                                                                      cNumericFields);
+
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, AlphArray(1)};
             // ErrorsFound will be set to True if problem was found, left untouched otherwise
             GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "HEATING";
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_HeatingAirToAirVariableSpeed;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType = HVAC::cAllCoilTypes(HVAC::Coil_HeatingAirToAirVariableSpeed);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat = NumArray(3);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+
+            vsCoil.bIsDesuperheater = false;
+            vsCoil.Name = AlphArray(1);
+            vsCoil.CoolHeatType = "HEATING";
+            vsCoil.coilType = HVAC::CoilType::HeatingDXVariableSpeed;
+            vsCoil.NumOfSpeeds = int(NumArray(1));
+            vsCoil.NormSpedLevel = int(NumArray(2));
+            vsCoil.RatedCapHeat = NumArray(3);
+            vsCoil.RatedAirVolFlowRate = NumArray(4);
 
             // Previously set by parent objects, but not user-definable
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = 4;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = 0.;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = 0.;
+            vsCoil.MaxONOFFCyclesperHour = 4;
+            vsCoil.LatentCapacityTimeConstant = 0.;
+            vsCoil.FanDelayTime = 0.;
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
+            vsCoil.AirInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(2),
                                   ErrorsFound,
@@ -1943,7 +1916,7 @@ namespace VariableSpeedCoils {
                                   DataLoopNode::ConnectionType::Inlet,
                                   NodeInputManager::CompFluidStream::Primary,
                                   DataLoopNode::ObjectIsNotParent);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
+            vsCoil.AirOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(3),
                                   ErrorsFound,
@@ -1956,92 +1929,79 @@ namespace VariableSpeedCoils {
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Air Nodes");
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
+            if (vsCoil.NumOfSpeeds < 1) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
                 ErrorsFound = true;
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+            if (vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) {
+                vsCoil.NormSpedLevel = vsCoil.NumOfSpeeds;
             }
 
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
+            if ((vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) || (vsCoil.NormSpedLevel <= 0)) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
                 ErrorsFound = true;
             }
 
             // part load curve
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
+            vsCoil.PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
+            if (vsCoil.PLFFPLR == 0) {
                 if (lAlphaBlanks(4)) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...required {} is blank.", cAlphaFields(4)));
                 } else {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(4), AlphArray(4)));
                 }
                 ErrorsFound = true;
             } else {
-                CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
+                CurveVal = Curve::CurveValue(state, vsCoil.PLFFPLR, 1.0);
                 if (CurveVal > 1.10 || CurveVal < 0.90) {
                     ShowWarningError(state,
                                      format("{}{}=\"{}\", curve values",
                                             RoutineName,
                                             CurrentModuleObject,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                            vsCoil.Name));
                     ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(4)));
                     ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
                 }
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT =
-                Curve::GetCurveIndex(state, AlphArray(5)); // convert curve name to number
-
-            if (!lAlphaBlanks(6)) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(6));
+            vsCoil.DefrostEIRFT = Curve::GetCurveIndex(state, AlphArray(5)); // convert curve name to number
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex == 0) { // can't find the curve
-                    ShowSevereError(state,
-                                    format("{} = {}:  {} not found = {}",
-                                           CurrentModuleObject,
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                                           cAlphaFields(6),
-                                           AlphArray(6)));
-                    ErrorsFound = true;
-                } else {
-                    ErrorsFound |=
-                        Curve::CheckCurveDims(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
-                                              {1},                                                        // Valid dimensions
-                                              RoutineName,                                                // Routine name
-                                              CurrentModuleObject,                                        // Object Type
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
-                                              cAlphaFields(6));                                           // Field Name
-                }
+            if (lAlphaBlanks(6)) {
+            } else if ((vsCoil.CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(6))) == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), AlphArray(6));
+                ErrorsFound = true;
+            } else {
+                ErrorsFound |=
+                    Curve::CheckCurveDims(state,
+                                          vsCoil.CrankcaseHeaterCapacityCurveIndex, // Curve index
+                                          {1},                                                                                     // Valid dimensions
+                                          RoutineName,                                                                             // Routine name
+                                          CurrentModuleObject,                                                                     // Object Type
+                                          vsCoil.Name,                              // Object Name
+                                          cAlphaFields(6));                                                                        // Field Name
             }
 
             if (Util::SameString(AlphArray(7), "ReverseCycle")) {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT == 0) {
+                if (vsCoil.DefrostEIRFT == 0) {
                     if (lAlphaBlanks(5)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(5)));
                         ShowContinueError(state, format("...field is required because {} is \"ReverseCycle\".", cAlphaFields(7)));
                     } else {
@@ -2049,144 +2009,140 @@ namespace VariableSpeedCoils {
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(5), AlphArray(5)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT, // Curve index
+                                                         vsCoil.DefrostEIRFT, // Curve index
                                                          {2},                                                                // Valid dimensions
                                                          RoutineName,                                                        // Routine name
                                                          CurrentModuleObject,                                                // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,         // Object Name
+                                                         vsCoil.Name,         // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                      // Field Name
                 }
             }
 
-            if (Util::SameString(AlphArray(7), "ReverseCycle")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = ReverseCycle;
-            if (Util::SameString(AlphArray(7), "Resistive")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = Resistive;
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == 0) {
+            if (Util::SameString(AlphArray(7), "ReverseCycle")) vsCoil.DefrostStrategy = ReverseCycle;
+            if (Util::SameString(AlphArray(7), "Resistive")) vsCoil.DefrostStrategy = Resistive;
+            if (vsCoil.DefrostStrategy == 0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...illegal {}=\"{}\".", cAlphaFields(7), AlphArray(7)));
                 ShowContinueError(state, "...valid values for this field are ReverseCycle or Resistive.");
                 ErrorsFound = true;
             }
 
-            if (Util::SameString(AlphArray(8), "Timed")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = Timed;
-            if (Util::SameString(AlphArray(8), "OnDemand")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = OnDemand;
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == 0) {
+            if (Util::SameString(AlphArray(8), "Timed")) vsCoil.DefrostControl = Timed;
+            if (Util::SameString(AlphArray(8), "OnDemand")) vsCoil.DefrostControl = OnDemand;
+            if (vsCoil.DefrostControl == 0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...illegal {}=\"{}\".", cAlphaFields(8), AlphArray(8)));
                 ShowContinueError(state, "...valid values for this field are Timed or OnDemand.");
                 ErrorsFound = true;
             }
 
             // Set minimum OAT for heat pump compressor operation
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor = NumArray(5);
+            vsCoil.MinOATCompressor = NumArray(5);
 
             // reserved for HSPF calculation
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OATempCompressorOn = NumArray(6);
+            vsCoil.OATempCompressorOn = NumArray(6);
 
             // Set maximum outdoor temp for defrost to occur
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost = NumArray(7);
+            vsCoil.MaxOATDefrost = NumArray(7);
 
             // Set crankcase heater capacity
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(8);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
+            vsCoil.CrankcaseHeaterCapacity = NumArray(8);
+            if (vsCoil.CrankcaseHeaterCapacity < 0.0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} cannot be < 0.0.", cNumericFields(9)));
                 ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(9)));
                 ErrorsFound = true;
             }
 
             // Set crankcase heater cutout temperature
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(9);
+            vsCoil.MaxOATCrankcaseHeater = NumArray(9);
 
             // Set defrost time period
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime = NumArray(10);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime == 0.0 &&
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == 1) {
+            vsCoil.DefrostTime = NumArray(10);
+            if (vsCoil.DefrostTime == 0.0 && vsCoil.DefrostControl == 1) {
                 ShowWarningError(
-                    state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} = 0.0 for defrost control = TIMED.", cNumericFields(5)));
             }
 
             // Set defrost capacity (for resistive defrost)
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity = NumArray(11);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity == 0.0 &&
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == 2) {
+            vsCoil.DefrostCapacity = NumArray(11);
+            if (vsCoil.DefrostCapacity == 0.0 && vsCoil.DefrostStrategy == 2) {
                 ShowWarningError(
-                    state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} = 0.0 for defrost strategy = RESISTIVE.", cNumericFields(6)));
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(14 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(15 + (I - 1) * 5);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(16 + (I - 1) * 5);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedTotCap(I) = NumArray(12 + (I - 1) * 5);
+                vsCoil.MSRatedCOP(I) = NumArray(13 + (I - 1) * 5);
+                vsCoil.MSRatedAirVolFlowRate(I) = NumArray(14 + (I - 1) * 5);
+                vsCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(15 + (I - 1) * 5);
+                vsCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(16 + (I - 1) * 5);
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) < 1.e-10) {
+                if (vsCoil.MSRatedTotCap(I) < 1.e-10) {
                     ShowSevereError(state,
                                     format("{}{}=\"{}\", invalid value",
                                            RoutineName,
                                            CurrentModuleObject,
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                           vsCoil.Name));
                     ShowContinueError(state,
                                       format("...too small {}=[{:.2R}].",
                                              cNumericFields(12 + (I - 1) * 3),
-                                             state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I)));
+                                             vsCoil.MSRatedTotCap(I)));
                     ErrorsFound = true;
                 }
 
                 AlfaFieldIncre = 9 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
+                vsCoil.MSCCapFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
+                                                         vsCoil.MSCCapFTemp(I), // Curve index
                                                          {2},                                                                  // Valid dimensions
                                                          RoutineName,                                                          // Routine name
                                                          CurrentModuleObject,                                                  // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,           // Object Name
+                                                         vsCoil.Name,           // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                        // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2195,43 +2151,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 10 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
+                vsCoil.MSCCapAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
+                                                         vsCoil.MSCCapAirFFlow(I), // Curve index
                                                          {1},                                                                     // Valid dimensions
                                                          RoutineName,                                                             // Routine name
                                                          CurrentModuleObject,                                                     // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,              // Object Name
+                                                         vsCoil.Name,              // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                           // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2240,44 +2195,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 11 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
+                vsCoil.MSEIRFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
+                                                         vsCoil.MSEIRFTemp(I), // Curve index
                                                          {2},                                                                 // Valid dimensions
                                                          RoutineName,                                                         // Routine name
                                                          CurrentModuleObject,                                                 // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,          // Object Name
+                                                         vsCoil.Name,          // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                       // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2286,43 +2239,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 12 + (I - 1) * 4;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
+                vsCoil.MSEIRAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
+                                                         vsCoil.MSEIRAirFFlow(I), // Curve index
                                                          {1},                                                                    // Valid dimensions
                                                          RoutineName,                                                            // Routine name
                                                          CurrentModuleObject,                                                    // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,             // Object Name
+                                                         vsCoil.Name,             // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                          // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2333,57 +2285,51 @@ namespace VariableSpeedCoils {
 
             if (ErrorsFound) continue;
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedPercentTotCap(I) = vsCoil.MSRatedTotCap(I) / vsCoil.MSRatedTotCap(vsCoil.NumOfSpeeds);
+                vsCoil.MSRatedAirVolFlowPerRatedTotCap(I) = vsCoil.MSRatedAirVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
             }
 
             // CurrentModuleObject = "Coil:Heating:DX:Variablespeed "
             SetupOutputVariable(state,
                                 "Heating Coil Electricity Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
+                                vsCoil.Energy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::Electricity,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::Heating);
             SetupOutputVariable(state,
                                 "Heating Coil Heating Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
+                                vsCoil.EnergyLoadTotal,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::EnergyTransfer,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::HeatingCoils);
             SetupOutputVariable(state,
                                 "Heating Coil Source Side Heat Transfer Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
+                                vsCoil.EnergySource,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
 
             // create predefined report entries
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilType, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, CurrentModuleObject);
+                state, state.dataOutRptPredefined->pdchHeatCoilType, vsCoil.Name, CurrentModuleObject);
             OutputReportPredefined::PreDefTableEntry(state,
                                                      state.dataOutRptPredefined->pdchHeatCoilNomCap,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat);
+                                                     vsCoil.Name,
+                                                     vsCoil.RatedCapHeat);
             OutputReportPredefined::PreDefTableEntry(state,
                                                      state.dataOutRptPredefined->pdchHeatCoilNomEff,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel));
+                                                     vsCoil.Name,
+                                                     vsCoil.MSRatedCOP(vsCoil.NormSpedLevel));
         }
 
         //-------------------------AIR SOURCE HEATING---END
@@ -2407,90 +2353,89 @@ namespace VariableSpeedCoils {
                                                                      lAlphaBlanks,
                                                                      cAlphaFields,
                                                                      cNumericFields);
+
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, AlphArray(1)};
+            
             // ErrorsFound will be set to True if problem was found, left untouched otherwise
             GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::WaterHeater;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "WATERHEATING";
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
-                HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed);
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
+            vsCoil.bIsDesuperheater = false;
+            vsCoil.CondenserType = DataHeatBalance::RefrigCondenserType::WaterHeater;
+            vsCoil.CoolHeatType = "WATERHEATING";
+            vsCoil.coilType = HVAC::CoilType::WaterHeatingAWHPVariableSpeed;
+            vsCoil.Name = AlphArray(1);
+            vsCoil.NumOfSpeeds = int(NumArray(1));
+            vsCoil.NormSpedLevel = int(NumArray(2));
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
+            if (vsCoil.NumOfSpeeds < 1) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
                 ErrorsFound = true;
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+            if (vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) {
+                vsCoil.NormSpedLevel = vsCoil.NumOfSpeeds;
             }
 
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
-                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
+            if ((vsCoil.NormSpedLevel > vsCoil.NumOfSpeeds) || (vsCoil.NormSpedLevel <= 0)) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
                 ErrorsFound = true;
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapWH = NumArray(3);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapWH <= 0.0) {
+            vsCoil.RatedCapWH = NumArray(3);
+            if (vsCoil.RatedCapWH <= 0.0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be > 0.0, entered value=[{:.2T}].", cNumericFields(3), NumArray(3)));
                 ErrorsFound = true;
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletDBTemp = NumArray(4);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWBTemp = NumArray(5);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp = NumArray(6);
+            vsCoil.WHRatedInletDBTemp = NumArray(4);
+            vsCoil.WHRatedInletWBTemp = NumArray(5);
+            vsCoil.WHRatedInletWaterTemp = NumArray(6);
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(7);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(8);
+            vsCoil.RatedAirVolFlowRate = NumArray(7);
+            vsCoil.RatedWaterVolFlowRate = NumArray(8);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate != Constant::AutoCalculate) {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate <= 0.0) {
+            if (vsCoil.RatedAirVolFlowRate != Constant::AutoCalculate) {
+                if (vsCoil.RatedAirVolFlowRate <= 0.0) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...{} must be > 0.0.  entered value=[{:.3T}].", cNumericFields(7), NumArray(7)));
                     ErrorsFound = true;
                 }
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate != Constant::AutoCalculate) {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate <= 0.0) {
+            if (vsCoil.RatedWaterVolFlowRate != Constant::AutoCalculate) {
+                if (vsCoil.RatedWaterVolFlowRate <= 0.0) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...{} must be > 0.0  entered value=[{:.3T}].", cNumericFields(8), NumArray(8)));
                     ErrorsFound = true;
                 }
             }
 
+            // Count how many times you are capitalizing AlphArray here (3) and comparing it to "No" (2)
             if (Util::SameString(AlphArray(2), "Yes") || Util::SameString(AlphArray(2), "No")) {
                 //  initialized to TRUE on allocate
                 if (Util::SameString(AlphArray(2), "No"))
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP = false;
+                    vsCoil.FanPowerIncludedInCOP = false;
                 else
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP = true;
+                    vsCoil.FanPowerIncludedInCOP = true;
             } else {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format(",,,invalid choice for {}.  Entered choice = {}", cAlphaFields(2), AlphArray(2)));
                 ShowContinueError(state, "Valid choices are Yes or No.");
                 ErrorsFound = true;
@@ -2499,13 +2444,13 @@ namespace VariableSpeedCoils {
             if (Util::SameString(AlphArray(3), "Yes") || Util::SameString(AlphArray(3), "No")) {
                 //  initialized to FALSE on allocate
                 if (Util::SameString(AlphArray(3), "Yes"))
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP = true;
+                    vsCoil.CondPumpPowerInCOP = true;
                 else
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP = false;
+                    vsCoil.CondPumpPowerInCOP = false;
             } else {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format(",,,invalid choice for {}.  Entered choice = {}", cAlphaFields(3), AlphArray(3)));
                 ShowContinueError(state, "Valid choices are Yes or No.");
                 ErrorsFound = true;
@@ -2514,34 +2459,33 @@ namespace VariableSpeedCoils {
             if (Util::SameString(AlphArray(4), "Yes") || Util::SameString(AlphArray(4), "No")) {
                 //  initialized to FALSE on allocate
                 if (Util::SameString(AlphArray(4), "Yes"))
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity = true;
+                    vsCoil.CondPumpHeatInCapacity = true;
                 else
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity = false;
+                    vsCoil.CondPumpHeatInCapacity = false;
             } else {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format(",,,invalid choice for {}.  Entered choice = {}", cAlphaFields(4), AlphArray(4)));
                 ShowContinueError(state, "Valid choices are Yes or No.");
                 ErrorsFound = true;
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = NumArray(9);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater <= 0.0 ||
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater > 1.0) {
+            vsCoil.HPWHCondPumpFracToWater = NumArray(9);
+            if (vsCoil.HPWHCondPumpFracToWater <= 0.0 || vsCoil.HPWHCondPumpFracToWater > 1.0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 0 and <= 1.  entered value=[{:.3T}].", cNumericFields(10), NumArray(9)));
                 ErrorsFound = true;
             }
 
-            if (!state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = 0.0;
+            if (!vsCoil.CondPumpHeatInCapacity) {
+                vsCoil.HPWHCondPumpFracToWater = 0.0;
             }
 
             // Air nodes
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
+            vsCoil.AirInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(5),
                                   ErrorsFound,
@@ -2552,7 +2496,7 @@ namespace VariableSpeedCoils {
                                   NodeInputManager::CompFluidStream::Primary,
                                   DataLoopNode::ObjectIsNotParent);
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
+            vsCoil.AirOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(6),
                                   ErrorsFound,
@@ -2566,11 +2510,10 @@ namespace VariableSpeedCoils {
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(5), AlphArray(6), "Air Nodes");
 
             // Check if the air inlet node is OA node, to justify whether the coil is placed in zone or not
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone =
-                !OutAirNodeManager::CheckOutAirNodeNumber(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum);
+            vsCoil.IsDXCoilInZone = !OutAirNodeManager::CheckOutAirNodeNumber(state, vsCoil.AirInletNodeNum);
 
             // Water nodes
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
+            vsCoil.WaterInletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(7),
                                   ErrorsFound,
@@ -2581,7 +2524,7 @@ namespace VariableSpeedCoils {
                                   NodeInputManager::CompFluidStream::Secondary,
                                   DataLoopNode::ObjectIsNotParent);
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
+            vsCoil.WaterOutletNodeNum =
                 GetOnlySingleNode(state,
                                   AlphArray(8),
                                   ErrorsFound,
@@ -2594,145 +2537,136 @@ namespace VariableSpeedCoils {
 
             BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(7), AlphArray(8), "Water Nodes");
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(10);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
+            vsCoil.CrankcaseHeaterCapacity = NumArray(10);
+            if (vsCoil.CrankcaseHeaterCapacity < 0.0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 0.0  entered value=[{:.1T}].", cNumericFields(10), NumArray(10)));
                 ErrorsFound = true;
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(11);
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater < 0.0) {
+            vsCoil.MaxOATCrankcaseHeater = NumArray(11);
+            if (vsCoil.MaxOATCrankcaseHeater < 0.0) {
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be >= 0 {{C}}.  entered value=[{:.1T}].", cNumericFields(11), NumArray(11)));
                 ErrorsFound = true;
             }
 
-            if (!lAlphaBlanks(9)) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(9));
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex == 0) { // can't find the curve
-                    ShowSevereError(state,
-                                    format("{} = {}:  {} not found = {}",
-                                           CurrentModuleObject,
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                                           cAlphaFields(9),
-                                           AlphArray(9)));
-                    ErrorsFound = true;
-                } else {
-                    ErrorsFound |=
-                        Curve::CheckCurveDims(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
-                                              {1},                                                        // Valid dimensions
-                                              RoutineName,                                                // Routine name
-                                              CurrentModuleObject,                                        // Object Type
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
-                                              cAlphaFields(9));                                           // Field Name
-                }
+            if (lAlphaBlanks(9)) {
+            } else if ((vsCoil.CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(9))) == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(9), AlphArray(9));
+                ErrorsFound = true;
+            } else {
+                ErrorsFound |=
+                    Curve::CheckCurveDims(state,
+                                          vsCoil.CrankcaseHeaterCapacityCurveIndex, // Curve index
+                                          {1},                                                                                     // Valid dimensions
+                                          RoutineName,                                                                             // Routine name
+                                          CurrentModuleObject,                                                                     // Object Type
+                                          vsCoil.Name,                              // Object Name
+                                          cAlphaFields(9));                                                                        // Field Name
             }
 
             if (Util::SameString(AlphArray(10), "DryBulbTemperature")) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType = HVAC::OATType::DryBulb;
+                vsCoil.InletAirTemperatureType = HVAC::OATType::DryBulb;
             } else if (Util::SameString(AlphArray(10), "WetBulbTemperature")) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType = HVAC::OATType::WetBulb;
+                vsCoil.InletAirTemperatureType = HVAC::OATType::WetBulb;
             } else {
                 //   wrong temperature type selection
                 ShowSevereError(
                     state,
-                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                    format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                 ShowContinueError(state, format("...{} must be DryBulbTemperature or WetBulbTemperature.", cAlphaFields(10)));
                 ShowContinueError(state, format("...entered value=\"{}\".", AlphArray(10)));
                 ErrorsFound = true;
             }
 
             // set rated inlet air temperature for curve object verification
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
-                WHInletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWBTemp;
+            if (vsCoil.InletAirTemperatureType == HVAC::OATType::WetBulb) {
+                WHInletAirTemp = vsCoil.WHRatedInletWBTemp;
             } else {
-                WHInletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletDBTemp;
+                WHInletAirTemp = vsCoil.WHRatedInletDBTemp;
             }
             // set rated water temperature for curve object verification
-            WHInletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp;
+            WHInletWaterTemp = vsCoil.WHRatedInletWaterTemp;
 
             // part load curve
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR =
+            vsCoil.PLFFPLR =
                 Curve::GetCurveIndex(state, AlphArray(11)); // convert curve name to number
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
+            if (vsCoil.PLFFPLR == 0) {
                 if (lAlphaBlanks(11)) {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...required {} is blank.", cAlphaFields(11)));
                 } else {
                     ShowSevereError(
                         state,
-                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                        format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, vsCoil.Name));
                     ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(11), AlphArray(11)));
                 }
                 ErrorsFound = true;
             } else {
-                CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
+                CurveVal = Curve::CurveValue(state, vsCoil.PLFFPLR, 1.0);
                 if (CurveVal > 1.10 || CurveVal < 0.90) {
                     ShowWarningError(state,
                                      format("{}{}=\"{}\", curve values",
                                             RoutineName,
                                             CurrentModuleObject,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                            vsCoil.Name));
                     ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(11)));
                     ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
                 }
             }
 
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(14 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) = NumArray(17 + (I - 1) * 6);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
+                vsCoil.MSRatedCOP(I) = NumArray(13 + (I - 1) * 6);
+                vsCoil.MSRatedSHR(I) = NumArray(14 + (I - 1) * 6);
+                vsCoil.MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
+                vsCoil.MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
+                vsCoil.MSWHPumpPower(I) = NumArray(17 + (I - 1) * 6);
 
                 AlfaFieldIncre = 12 + (I - 1) * 6;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
+                vsCoil.MSCCapFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
+                                                         vsCoil.MSCCapFTemp(I), // Curve index
                                                          {2},                                                                  // Valid dimensions
                                                          RoutineName,                                                          // Routine name
                                                          CurrentModuleObject,                                                  // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,           // Object Name
+                                                         vsCoil.Name,           // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                        // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), WHInletAirTemp, WHInletWaterTemp);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapFTemp(I), WHInletAirTemp, WHInletWaterTemp);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2741,43 +2675,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 13 + (I - 1) * 6;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
+                vsCoil.MSCCapAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
+                                                         vsCoil.MSCCapAirFFlow(I), // Curve index
                                                          {1},                                                                     // Valid dimensions
                                                          RoutineName,                                                             // Routine name
                                                          CurrentModuleObject,                                                     // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,              // Object Name
+                                                         vsCoil.Name,              // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                           // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2786,43 +2719,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 14 + (I - 1) * 6;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) == 0) {
+                vsCoil.MSCCapWaterFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSCCapWaterFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
+                                                         vsCoil.MSCCapWaterFFlow(I), // Curve index
                                                          {1},                                                        // Valid dimensions
                                                          RoutineName,                                                // Routine name
                                                          CurrentModuleObject,                                        // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
+                                                         vsCoil.Name, // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                              // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2831,44 +2763,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 15 + (I - 1) * 6;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
+                vsCoil.MSEIRFTemp(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRFTemp(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is BiQuadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
+                                                         vsCoil.MSEIRFTemp(I), // Curve index
                                                          {2},                                                                 // Valid dimensions
                                                          RoutineName,                                                         // Routine name
                                                          CurrentModuleObject,                                                 // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,          // Object Name
+                                                         vsCoil.Name,          // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                       // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(
-                            state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), WHInletAirTemp, WHInletWaterTemp);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRFTemp(I), WHInletAirTemp, WHInletWaterTemp);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2877,43 +2807,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 16 + (I - 1) * 6;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
+                vsCoil.MSEIRAirFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRAirFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
+                                                         vsCoil.MSEIRAirFFlow(I), // Curve index
                                                          {1},                                                                    // Valid dimensions
                                                          RoutineName,                                                            // Routine name
                                                          CurrentModuleObject,                                                    // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,             // Object Name
+                                                         vsCoil.Name,             // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                          // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2922,43 +2851,42 @@ namespace VariableSpeedCoils {
                 }
 
                 AlfaFieldIncre = 17 + (I - 1) * 6;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
-                    Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) == 0) {
+                vsCoil.MSEIRWaterFFlow(I) = Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
+                if (vsCoil.MSEIRWaterFFlow(I) == 0) {
                     if (lAlphaBlanks(AlfaFieldIncre)) {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", missing",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
                     } else {
                         ShowSevereError(state,
                                         format("{}{}=\"{}\", invalid",
                                                RoutineName,
                                                CurrentModuleObject,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                               vsCoil.Name));
                         ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
                     }
                     ErrorsFound = true;
                 } else {
                     // Verify Curve Object, only legal type is Quadratic
                     ErrorsFound |= Curve::CheckCurveDims(state,
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
+                                                         vsCoil.MSEIRWaterFFlow(I), // Curve index
                                                          {1},                                                                      // Valid dimensions
                                                          RoutineName,                                                              // Routine name
                                                          CurrentModuleObject,                                                      // Object Type
-                                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,               // Object Name
+                                                         vsCoil.Name,               // Object Name
                                                          cAlphaFields(AlfaFieldIncre));                                            // Field Name
 
                     if (!ErrorsFound) {
-                        CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
+                        CurveVal = Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(I), 1.0);
                         if (CurveVal > 1.10 || CurveVal < 0.90) {
                             ShowWarningError(state,
                                              format("{}{}=\"{}\", curve values",
                                                     RoutineName,
                                                     CurrentModuleObject,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
+                                                    vsCoil.Name));
                             ShowContinueError(
                                 state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
                             ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
@@ -2968,66 +2896,57 @@ namespace VariableSpeedCoils {
             }
 
             // get scale values
-            for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPowerPerRatedTotCap(I) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
+            for (int I = 1; I <= vsCoil.NumOfSpeeds; ++I) {
+                vsCoil.MSRatedPercentTotCap(I) = vsCoil.MSRatedTotCap(I) / vsCoil.MSRatedTotCap(vsCoil.NumOfSpeeds);
+                vsCoil.MSRatedAirVolFlowPerRatedTotCap(I) = vsCoil.MSRatedAirVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
+                vsCoil.MSRatedWaterVolFlowPerRatedTotCap(I) = vsCoil.MSRatedWaterVolFlowRate(I) / vsCoil.MSRatedTotCap(I);
+                vsCoil.MSWHPumpPowerPerRatedTotCap(I) = vsCoil.MSWHPumpPower(I) / vsCoil.MSRatedTotCap(I);
             }
 
             // CurrentModuleObject = "Coil:Waterheating:Airtowaterheatpump:Variablespeed"
             SetupOutputVariable(state,
                                 "Cooling Coil Electricity Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
+                                vsCoil.Energy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::Electricity,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::Heating);
             SetupOutputVariable(state,
                                 "Cooling Coil Sensible Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
+                                vsCoil.EnergySensible,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
             SetupOutputVariable(state,
                                 "Cooling Coil Latent Cooling Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
+                                vsCoil.EnergyLatent,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                vsCoil.Name);
             SetupOutputVariable(state,
                                 "Cooling Coil Water Side Heat Transfer Energy",
                                 Constant::Units::J,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
+                                vsCoil.EnergySource,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                vsCoil.Name,
                                 Constant::eResource::PlantLoopHeatingDemand,
                                 OutputProcessor::Group::HVAC,
                                 OutputProcessor::EndUseCat::HeatingCoils);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone) {
+            if (vsCoil.IsDXCoilInZone) {
                 SetupOutputVariable(state,
                                     "Cooling Coil Cooling Energy",
                                     Constant::Units::J,
-                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
+                                    vsCoil.EnergyLoadTotal,
                                     OutputProcessor::TimeStepType::System,
                                     OutputProcessor::StoreType::Sum,
-                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                    vsCoil.Name,
                                     Constant::eResource::EnergyTransfer,
                                     OutputProcessor::Group::HVAC,
                                     OutputProcessor::EndUseCat::CoolingCoils);
@@ -3035,14 +2954,13 @@ namespace VariableSpeedCoils {
                 SetupOutputVariable(state,
                                     "Cooling Coil Cooling Energy",
                                     Constant::Units::J,
-                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
+                                    vsCoil.EnergyLoadTotal,
                                     OutputProcessor::TimeStepType::System,
                                     OutputProcessor::StoreType::Sum,
-                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                    vsCoil.Name);
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolSens =
-                DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
+            vsCoil.RatedCapCoolSens = DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
         }
         //---------------------------VARIABLE-SPEED AIR SOURCE HPWH END --------------
 
@@ -3058,192 +2976,193 @@ namespace VariableSpeedCoils {
         }
 
         for (DXCoilNum = 1; DXCoilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils; ++DXCoilNum) {
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+            if ((vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) ||
+                (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed)) {
                 // Setup Report variables for the Heat Pump
 
                 // cooling and heating coils separately
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     // air source cooling coils
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
+                                        vsCoil.AirMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
+                                        vsCoil.InletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Inlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
+                                        vsCoil.InletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Latent Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
+                                        vsCoil.QLatent,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
+                                        vsCoil.OutletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Outlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                                        vsCoil.OutletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Sensible Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
+                                        vsCoil.QSensible,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Total Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
+                                        vsCoil.QLoadTotal,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Part Load Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
+                                        vsCoil.PartLoadRatio,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
+                                        vsCoil.Power,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Runtime Fraction",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
+                                        vsCoil.RunFrac,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Source Side Heat Transfer Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
+                                        vsCoil.QSource,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Upper Speed Level",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
+                                        vsCoil.SpeedNumReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Neighboring Speed Levels Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
+                                        vsCoil.SpeedRatioReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
-                    if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode == CondensateToTank) {
+                    if (vsCoil.CondensateCollectMode == CondensateToTank) {
                         SetupOutputVariable(state,
                                             "Cooling Coil Condensate Volume Flow Rate",
                                             Constant::Units::m3_s,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot,
+                                            vsCoil.CondensateVdot,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Average,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                            vsCoil.Name);
                         SetupOutputVariable(state,
                                             "Cooling Coil Condensate Volume",
                                             Constant::Units::m3,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol,
+                                            vsCoil.CondensateVol,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Sum,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                            vsCoil.Name,
                                             Constant::eResource::OnSiteWater,
                                             OutputProcessor::Group::HVAC,
                                             OutputProcessor::EndUseCat::Condensate);
                     }
 
-                    if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ReportEvapCondVars) {
+                    if (vsCoil.ReportEvapCondVars) {
                         SetupOutputVariable(state,
                                             "Cooling Coil Condenser Inlet Temperature",
                                             Constant::Units::C,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondInletTemp,
+                                            vsCoil.CondInletTemp,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Average,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                            vsCoil.Name);
                         SetupOutputVariable(state,
                                             "Cooling Coil Evaporative Condenser Water Volume",
                                             Constant::Units::m3,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
+                                            vsCoil.EvapWaterConsump,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Sum,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                            vsCoil.Name,
                                             Constant::eResource::Water,
                                             OutputProcessor::Group::HVAC,
                                             OutputProcessor::EndUseCat::Cooling);
                         SetupOutputVariable(state,
                                             "Cooling Coil Evaporative Condenser Mains Water Volume",
                                             Constant::Units::m3,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
+                                            vsCoil.EvapWaterConsump,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Sum,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                            vsCoil.Name,
                                             Constant::eResource::MainsWater,
                                             OutputProcessor::Group::HVAC,
                                             OutputProcessor::EndUseCat::Cooling);
                         SetupOutputVariable(state,
                                             "Cooling Coil Evaporative Condenser Pump Electricity Rate",
                                             Constant::Units::W,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower,
+                                            vsCoil.EvapCondPumpElecPower,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Average,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                            vsCoil.Name);
                         SetupOutputVariable(state,
                                             "Cooling Coil Evaporative Condenser Pump Electricity Energy",
                                             Constant::Units::J,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
+                                            vsCoil.EvapCondPumpElecConsumption,
                                             OutputProcessor::TimeStepType::System,
                                             OutputProcessor::StoreType::Sum,
-                                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                            vsCoil.Name,
                                             Constant::eResource::Electricity,
                                             OutputProcessor::Group::HVAC,
                                             OutputProcessor::EndUseCat::Cooling);
-                        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff > 0.0) {
+                        if (vsCoil.BasinHeaterPowerFTempDiff > 0.0) {
                             SetupOutputVariable(state,
                                                 "Cooling Coil Basin Heater Electricity Rate",
                                                 Constant::Units::W,
-                                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower,
+                                                vsCoil.BasinHeaterPower,
                                                 OutputProcessor::TimeStepType::System,
                                                 OutputProcessor::StoreType::Average,
-                                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                                vsCoil.Name);
                             SetupOutputVariable(state,
                                                 "Cooling Coil Basin Heater Electricity Energy",
                                                 Constant::Units::J,
-                                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption,
+                                                vsCoil.BasinHeaterConsumption,
                                                 OutputProcessor::TimeStepType::System,
                                                 OutputProcessor::StoreType::Sum,
-                                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                                vsCoil.Name,
                                                 Constant::eResource::Electricity,
                                                 OutputProcessor::Group::HVAC,
                                                 OutputProcessor::EndUseCat::Cooling);
@@ -3253,17 +3172,17 @@ namespace VariableSpeedCoils {
                     SetupOutputVariable(state,
                                         "Cooling Coil Crankcase Heater Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
+                                        vsCoil.CrankcaseHeaterPower,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Crankcase Heater Electricity Energy",
                                         Constant::Units::J,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
+                                        vsCoil.CrankcaseHeaterConsumption,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Sum,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                        vsCoil.Name,
                                         Constant::eResource::Electricity,
                                         OutputProcessor::Group::HVAC,
                                         OutputProcessor::EndUseCat::Cooling);
@@ -3272,532 +3191,531 @@ namespace VariableSpeedCoils {
                     SetupOutputVariable(state,
                                         "Heating Coil Air Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
+                                        vsCoil.AirMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
+                                        vsCoil.InletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Inlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
+                                        vsCoil.InletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
+                                        vsCoil.OutletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Outlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                                        vsCoil.OutletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Sensible Heating Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
+                                        vsCoil.QSensible,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Heating Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
+                                        vsCoil.QLoadTotal,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Part Load Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
+                                        vsCoil.PartLoadRatio,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
+                                        vsCoil.Power,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Runtime Fraction",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
+                                        vsCoil.RunFrac,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Heating Coil Source Side Heat Transfer Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
+                                        vsCoil.QSource,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Upper Speed Level",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
+                                        vsCoil.SpeedNumReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Neighboring Speed Levels Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
+                                        vsCoil.SpeedRatioReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Heating Coil Defrost Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower,
+                                        vsCoil.DefrostPower,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Defrost Electricity Energy",
                                         Constant::Units::J,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption,
+                                        vsCoil.DefrostConsumption,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Sum,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                        vsCoil.Name,
                                         Constant::eResource::Electricity,
                                         OutputProcessor::Group::HVAC,
                                         OutputProcessor::EndUseCat::Heating);
                     SetupOutputVariable(state,
                                         "Heating Coil Crankcase Heater Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
+                                        vsCoil.CrankcaseHeaterPower,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Crankcase Heater Electricity Energy",
                                         Constant::Units::J,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
+                                        vsCoil.CrankcaseHeaterConsumption,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Sum,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                        vsCoil.Name,
                                         Constant::eResource::Electricity,
                                         OutputProcessor::Group::HVAC,
                                         OutputProcessor::EndUseCat::Heating);
 
                     if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                         SetupEMSActuator(state,
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                         HVAC::coilTypeNames[(int)vsCoil.coilType],
+                                         vsCoil.Name,
                                          "Frost Heating Capacity Multiplier",
                                          "[]",
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn,
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue);
+                                         vsCoil.FrostHeatingCapacityMultiplierEMSOverrideOn,
+                                         vsCoil.FrostHeatingCapacityMultiplierEMSOverrideValue);
 
                         SetupEMSActuator(state,
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                         HVAC::coilTypeNames[(int)vsCoil.coilType],
+                                         vsCoil.Name,
                                          "Frost Heating Input Power Multiplier",
                                          "[]",
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn,
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue);
+                                         vsCoil.FrostHeatingInputPowerMultiplierEMSOverrideOn,
+                                         vsCoil.FrostHeatingInputPowerMultiplierEMSOverrideValue);
                     }
                 }
             } else {
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
-                    HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // fix coil type
+                if (vsCoil.coilType ==
+                    HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) { // fix coil type
                     // cooling WAHP coil
                     // Setup Report variables for water source Heat Pump
                     SetupOutputVariable(state,
                                         "Cooling Coil Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
+                                        vsCoil.Power,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Total Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
+                                        vsCoil.QLoadTotal,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Sensible Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
+                                        vsCoil.QSensible,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Latent Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
+                                        vsCoil.QLatent,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Source Side Heat Transfer Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
+                                        vsCoil.QSource,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Part Load Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
+                                        vsCoil.PartLoadRatio,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Runtime Fraction",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
+                                        vsCoil.RunFrac,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
+                                        vsCoil.AirMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
+                                        vsCoil.InletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Inlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
+                                        vsCoil.InletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
+                                        vsCoil.OutletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Outlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                                        vsCoil.OutletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Source Side Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
+                                        vsCoil.WaterMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Source Side Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
+                                        vsCoil.InletWaterTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Source Side Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
+                                        vsCoil.OutletWaterTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Cooling Coil Upper Speed Level",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
+                                        vsCoil.SpeedNumReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Neighboring Speed Levels Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
+                                        vsCoil.SpeedRatioReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Recoverable Heat Transfer Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
+                                        vsCoil.QWasteHeat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
-                } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
-                           HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // fix coil type
+                                        vsCoil.Name);
+                } else if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) { // fix coil type
                     // heating WAHP coil
                     // Setup Report variables for water source Heat Pump
                     SetupOutputVariable(state,
                                         "Heating Coil Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
+                                        vsCoil.Power,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Heating Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
+                                        vsCoil.QLoadTotal,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Sensible Heating Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
+                                        vsCoil.QSensible,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Heating Coil Source Side Heat Transfer Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
+                                        vsCoil.QSource,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Part Load Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
+                                        vsCoil.PartLoadRatio,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Runtime Fraction",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
+                                        vsCoil.RunFrac,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Heating Coil Air Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
+                                        vsCoil.AirMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
+                                        vsCoil.InletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Inlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
+                                        vsCoil.InletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
+                                        vsCoil.OutletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Air Outlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                                        vsCoil.OutletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Source Side Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
+                                        vsCoil.WaterMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Source Side Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
+                                        vsCoil.InletWaterTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Source Side Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
+                                        vsCoil.OutletWaterTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Heating Coil Upper Speed Level",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
+                                        vsCoil.SpeedNumReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Neighboring Speed Levels Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
+                                        vsCoil.SpeedRatioReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Heating Coil Recoverable Heat Transfer Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
+                                        vsCoil.QWasteHeat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
-                } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
+                                        vsCoil.Name);
+                } else if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
                     // air source water heating coil
                     SetupOutputVariable(state,
                                         "Cooling Coil Water Heating Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
+                                        vsCoil.Power,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Total Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
+                                        vsCoil.QLoadTotal,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Sensible Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
+                                        vsCoil.QSensible,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Latent Cooling Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
+                                        vsCoil.QLatent,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Total Water Heating Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate,
+                                        vsCoil.TotalHeatingEnergyRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Part Load Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
+                                        vsCoil.PartLoadRatio,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Runtime Fraction",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
+                                        vsCoil.RunFrac,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
+                                        vsCoil.AirMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
+                                        vsCoil.InletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Inlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
+                                        vsCoil.InletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
+                                        vsCoil.OutletAirDBTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Air Outlet Humidity Ratio",
                                         Constant::Units::kgWater_kgDryAir,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                                        vsCoil.OutletAirHumRat,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Water Mass Flow Rate",
                                         Constant::Units::kg_s,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
+                                        vsCoil.WaterMassFlowRate,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Water Inlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
+                                        vsCoil.InletWaterTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Water Outlet Temperature",
                                         Constant::Units::C,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
+                                        vsCoil.OutletWaterTemp,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Cooling Coil Crankcase Heater Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
+                                        vsCoil.CrankcaseHeaterPower,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Crankcase Heater Electricity Energy",
                                         Constant::Units::J,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
+                                        vsCoil.CrankcaseHeaterConsumption,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Sum,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                        vsCoil.Name,
                                         Constant::eResource::Electricity,
                                         OutputProcessor::Group::HVAC,
                                         OutputProcessor::EndUseCat::Heating);
@@ -3805,32 +3723,32 @@ namespace VariableSpeedCoils {
                     SetupOutputVariable(state,
                                         "Cooling Coil Upper Speed Level",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
+                                        vsCoil.SpeedNumReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Neighboring Speed Levels Ratio",
                                         Constant::Units::None,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
+                                        vsCoil.SpeedRatioReport,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
 
                     SetupOutputVariable(state,
                                         "Cooling Coil Water Heating Pump Electricity Rate",
                                         Constant::Units::W,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower,
+                                        vsCoil.HPWHCondPumpElecNomPower,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Average,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
+                                        vsCoil.Name);
                     SetupOutputVariable(state,
                                         "Cooling Coil Water Heating Pump Electricity Energy",
                                         Constant::Units::J,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
+                                        vsCoil.EvapCondPumpElecConsumption,
                                         OutputProcessor::TimeStepType::System,
                                         OutputProcessor::StoreType::Sum,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                        vsCoil.Name,
                                         Constant::eResource::Electricity,
                                         OutputProcessor::Group::HVAC,
                                         OutputProcessor::EndUseCat::Heating);
@@ -3885,7 +3803,8 @@ namespace VariableSpeedCoils {
 
         // SUBROUTINE PARAMETER DEFINITIONS:
         static constexpr std::string_view RoutineName = "InitVarSpeedCoil";
-        int AirInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
+
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
 
         if (state.dataVariableSpeedCoils->MyOneTimeFlag) {
             // initialize the environment and sizing flags
@@ -3902,7 +3821,7 @@ namespace VariableSpeedCoils {
                                                                 // member from DXcoils.cc is added to VarSpeedCoil object
 
         // variable-speed heat pump water heating, begin
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed &&
+        if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed &&
             state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum)) {
 
             ErrorsFound = false;
@@ -3918,21 +3837,21 @@ namespace VariableSpeedCoils {
         // variable-speed heat pump water heating, end
 
         // water source
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) { // fix coil type
+        if ((vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) ||
+            (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit)) { // fix coil type
             if (state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) && allocated(state.dataPlnt->PlantLoop)) {
                 // switch from coil type numbers in DataHVACGlobals, to coil type numbers in plant.
                 DataPlant::PlantEquipmentType CoilVSWAHPType(DataPlant::PlantEquipmentType::Invalid);
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) {
                     CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPCoolingEquationFit;
-                } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+                } else if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
                     CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPHeatingEquationFit;
                 }
                 ErrorsFound = false;
                 PlantUtilities::ScanPlantLoopsForObject(state,
-                                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                                        vsCoil.Name,
                                                         CoilVSWAHPType,
-                                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc,
+                                                        vsCoil.plantLoc,
                                                         ErrorsFound,
                                                         _,
                                                         _,
@@ -3960,24 +3879,24 @@ namespace VariableSpeedCoils {
             state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) = false;
 
             // Multispeed Cooling
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
-                for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
-                    if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) break;
+            if ((vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) ||
+                (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed)) {
+                for (int Mode = 1; Mode <= vsCoil.NumOfSpeeds; ++Mode) {
+                    if (vsCoil.RatedCapCoolTotal <= 0.0) break;
                     // Check for zero capacity or zero max flow rate
-                    if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode) <= 0.0) {
+                    if (vsCoil.MSRatedTotCap(Mode) <= 0.0) {
                         ShowSevereError(state,
                                         format("Sizing: {} {} has zero rated total capacity at speed {}",
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                               HVAC::coilTypeNames[(int)vsCoil.coilType],
+                                               vsCoil.Name,
                                                Mode));
                         ErrorsFound = true;
                     }
-                    if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) <= 0.0) {
+                    if (vsCoil.MSRatedAirVolFlowRate(Mode) <= 0.0) {
                         ShowSevereError(state,
                                         format("Sizing: {} {} has zero rated air flow rate at speed {}",
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
+                                               HVAC::coilTypeNames[(int)vsCoil.coilType],
+                                               vsCoil.Name,
                                                Mode));
                         ErrorsFound = true;
                     }
@@ -3985,23 +3904,17 @@ namespace VariableSpeedCoils {
                         ShowFatalError(state, "Preceding condition causes termination.");
                     }
                     // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
-                    RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
+                    RatedVolFlowPerRatedTotCap = vsCoil.MSRatedAirVolFlowRate(Mode) / vsCoil.MSRatedTotCap(Mode);
                 }
                 // call coil model with everything set at rating point
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTemp;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
+                vsCoil.InletAirDBTemp = RatedInletAirTemp;
+                vsCoil.InletAirHumRat =
                     Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTemp, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
-                    Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
+                vsCoil.InletAirEnthalpy = Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, vsCoil.InletAirHumRat);
+                vsCoil.InletAirPressure = DataEnvironment::StdPressureSeaLevel;
 
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
-                    Psychrometrics::PsyRhoAirFnPbTdbW(state,
-                                                      DataEnvironment::StdPressureSeaLevel,
-                                                      RatedInletAirTemp,
-                                                      state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
+                vsCoil.AirMassFlowRate = vsCoil.RatedAirVolFlowRate *
+                    Psychrometrics::PsyRhoAirFnPbTdbW(state, DataEnvironment::StdPressureSeaLevel, RatedInletAirTemp, vsCoil.InletAirHumRat);
                 // store environment data fill back in after rating point calc is over
                 Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
                 Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
@@ -4014,41 +3927,26 @@ namespace VariableSpeedCoils {
                 state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
                 state.dataEnvrn->OutHumRat =
                     Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTemp, ratedOutdoorAirWetBulb, DataEnvironment::StdPressureSeaLevel, RoutineName);
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum > 0) {
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp = RatedAmbAirTemp;
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat =
-                        state.dataEnvrn->OutHumRat;
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press =
-                        DataEnvironment::StdPressureSeaLevel;
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb =
-                        ratedOutdoorAirWetBulb;
+                if (vsCoil.CondenserInletNodeNum > 0) {
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Temp = RatedAmbAirTemp;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).HumRat = state.dataEnvrn->OutHumRat;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Press = DataEnvironment::StdPressureSeaLevel;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).OutAirWetBulb = ratedOutdoorAirWetBulb;
                 }
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
-                    HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
-                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTemp; // 85 F cooling mode
-                    Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
+                if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit) { // need to set water info for WSHP
+                    vsCoil.WaterMassFlowRate = vsCoil.MSRatedWaterMassFlowRate(vsCoil.NumOfSpeeds);
+                    vsCoil.InletWaterTemp = RatedInletWaterTemp; // 85 F cooling mode
+                    Real64 CpSource = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                                           .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
+                    vsCoil.InletWaterEnthalpy = vsCoil.InletWaterTemp * CpSource;
                 }
 
                 // calculate coil model at rating point
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
+                vsCoil.RunFrac = 1.0;
+                vsCoil.DesignAirMassFlowRate = vsCoil.MSRatedAirMassFlowRate(vsCoil.NumOfSpeeds);
+                vsCoil.DesignAirVolFlowRate = vsCoil.MSRatedAirVolFlowRate(vsCoil.NumOfSpeeds);
+                vsCoil.DesignWaterMassFlowRate = vsCoil.MSRatedWaterMassFlowRate(vsCoil.NumOfSpeeds);
+                vsCoil.DesignWaterVolFlowRate = vsCoil.MSRatedWaterVolFlowRate(vsCoil.NumOfSpeeds);
 
                 CalcVarSpeedCoilCooling(state,
                                         DXCoilNum,
@@ -4059,31 +3957,30 @@ namespace VariableSpeedCoils {
                                         1.0,
                                         1.0,
                                         1.0,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
+                                        vsCoil.NumOfSpeeds);
                 // coil outlets
                 Real64 RatedOutletWetBulb(0.0);
                 RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
-                                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
-                                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                                                                    vsCoil.OutletAirDBTemp,
+                                                                    vsCoil.OutletAirHumRat,
                                                                     DataEnvironment::StdPressureSeaLevel,
                                                                     RoutineName);
-                state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
+                ReportCoilSelection::setRatedCoilConditions(
                     state,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,  // this is the report variable
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
+                    vsCoil.Name,
+                    vsCoil.coilType,
+                    vsCoil.QLoadTotal, // this is the report variable
+                    vsCoil.QSensible,  // this is the report variable
+                    vsCoil.AirMassFlowRate,
+                    vsCoil.InletAirDBTemp,
+                    vsCoil.InletAirHumRat,
                     RatedInletWetBulbTemp,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                    vsCoil.OutletAirDBTemp,
+                    vsCoil.OutletAirHumRat,
                     RatedOutletWetBulb,
                     RatedAmbAirTemp,
                     ratedOutdoorAirWetBulb,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
+                    vsCoil.MSRatedCBF(vsCoil.NumOfSpeeds),
                     -999.0); // coil effectiveness not define for DX
 
                 // now replace the outdoor air conditions set above for one time rating point calc
@@ -4094,34 +3991,31 @@ namespace VariableSpeedCoils {
             }
 
             // Multispeed Heating
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
+            if ((vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) ||
+                (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed)) {
                 RatedHeatPumpIndoorAirTemp = 21.11;  // 21.11C or 70F
                 RatedHeatPumpIndoorHumRat = 0.00881; // Humidity ratio corresponding to 70F dry bulb/60F wet bulb
-                for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
+                for (int Mode = 1; Mode <= vsCoil.NumOfSpeeds; ++Mode) {
 
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(Mode) =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) *
+                    vsCoil.MSRatedAirMassFlowRate(Mode) = vsCoil.MSRatedAirVolFlowRate(Mode) *
                         Psychrometrics::PsyRhoAirFnPbTdbW(
                             state, state.dataEnvrn->OutBaroPress, RatedHeatPumpIndoorAirTemp, RatedHeatPumpIndoorHumRat, RoutineName);
                     // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
-                    RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
+                    RatedVolFlowPerRatedTotCap = vsCoil.MSRatedAirVolFlowRate(Mode) / vsCoil.MSRatedTotCap(Mode);
                 }
                 // call coil model with everthing set at rating point
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTempHeat;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
+                vsCoil.InletAirDBTemp = RatedInletAirTempHeat;
+                vsCoil.InletAirHumRat =
                     Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTempHeat, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
-                    Psychrometrics::PsyHFnTdbW(RatedInletAirTempHeat, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
+                vsCoil.InletAirEnthalpy = Psychrometrics::PsyHFnTdbW(RatedInletAirTempHeat, vsCoil.InletAirHumRat);
+                vsCoil.InletAirPressure = DataEnvironment::StdPressureSeaLevel;
 
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
+                vsCoil.AirMassFlowRate =
+                    vsCoil.RatedAirVolFlowRate *
                     Psychrometrics::PsyRhoAirFnPbTdbW(state,
                                                       DataEnvironment::StdPressureSeaLevel,
                                                       RatedInletAirTempHeat,
-                                                      state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
+                                                      vsCoil.InletAirHumRat);
                 // store environment data fill back in after rating point calc is over
                 Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
                 Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
@@ -4133,42 +4027,27 @@ namespace VariableSpeedCoils {
                 state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
                 state.dataEnvrn->OutHumRat =
                     Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTempHeat, RatedAmbAirWBHeat, DataEnvironment::StdPressureSeaLevel, RoutineName);
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum > 0) {
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp = RatedAmbAirTempHeat;
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat =
-                        state.dataEnvrn->OutHumRat;
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press =
-                        DataEnvironment::StdPressureSeaLevel;
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb =
-                        RatedAmbAirWBHeat;
+                if (vsCoil.CondenserInletNodeNum > 0) {
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Temp = RatedAmbAirTempHeat;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).HumRat = state.dataEnvrn->OutHumRat;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Press = DataEnvironment::StdPressureSeaLevel;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).OutAirWetBulb = RatedAmbAirWBHeat;
                 }
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
-                    HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
-                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTempHeat; // 21.11C or 70F, heating mode
-                    Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
+                if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) { // need to set water info for WSHP
+                    vsCoil.WaterMassFlowRate = vsCoil.MSRatedWaterMassFlowRate(vsCoil.NumOfSpeeds);
+                    vsCoil.InletWaterTemp = RatedInletWaterTempHeat; // 21.11C or 70F, heating mode
+                    Real64 CpSource = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                                           .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
+                    vsCoil.InletWaterEnthalpy = vsCoil.InletWaterTemp * CpSource;
                 }
 
                 // calculate coil model at rating point
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
+                vsCoil.RunFrac = 1.0;
+                vsCoil.DesignAirMassFlowRate = vsCoil.MSRatedAirMassFlowRate(vsCoil.NumOfSpeeds);
+                vsCoil.DesignAirVolFlowRate = vsCoil.MSRatedAirVolFlowRate(vsCoil.NumOfSpeeds);
+                vsCoil.DesignWaterMassFlowRate = vsCoil.MSRatedWaterMassFlowRate(vsCoil.NumOfSpeeds);
+                vsCoil.DesignWaterVolFlowRate = vsCoil.MSRatedWaterVolFlowRate(vsCoil.NumOfSpeeds);
                 CalcVarSpeedCoilHeating(state,
                                         DXCoilNum,
                                         HVAC::FanOp::Continuous,
@@ -4177,31 +4056,30 @@ namespace VariableSpeedCoils {
                                         1.0,
                                         1.0,
                                         1.0,
-                                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
+                                        vsCoil.NumOfSpeeds);
                 // coil outlets
                 Real64 RatedOutletWetBulb(0.0);
                 RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
-                                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
-                                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                                                                    vsCoil.OutletAirDBTemp,
+                                                                    vsCoil.OutletAirHumRat,
                                                                     DataEnvironment::StdPressureSeaLevel,
                                                                     RoutineName);
-                state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
+                ReportCoilSelection::setRatedCoilConditions(
                     state,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,  // this is the report variable
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
+                    vsCoil.Name,
+                    vsCoil.coilType,
+                    vsCoil.QLoadTotal, // this is the report variable
+                    vsCoil.QSensible,  // this is the report variable
+                    vsCoil.AirMassFlowRate,
+                    vsCoil.InletAirDBTemp,
+                    vsCoil.InletAirHumRat,
                     RatedInletWetBulbTemp,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
+                    vsCoil.OutletAirDBTemp,
+                    vsCoil.OutletAirHumRat,
                     RatedOutletWetBulb,
                     RatedAmbAirTempHeat,
                     RatedAmbAirWBHeat,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
+                    vsCoil.MSRatedCBF(vsCoil.NumOfSpeeds),
                     -999.0); // coil effectiveness not define for DX
 
                 // now replace the outdoor air conditions set above for one time rating point calc
@@ -4212,46 +4090,43 @@ namespace VariableSpeedCoils {
             }
 
             // store fan info for coil
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
+            if (vsCoil.SupplyFanIndex > 0) {
+                ReportCoilSelection::setCoilSupplyFanInfo(
                     state,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanName,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).supplyFanType,
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex);
+                    vsCoil.Name,
+                    vsCoil.coilType,
+                    vsCoil.SupplyFanName,
+                    vsCoil.supplyFanType,
+                    vsCoil.SupplyFanIndex);
             }
         }
 
-        if (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
-            SpeedCal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+        if (SpeedNum > vsCoil.NumOfSpeeds) {
+            SpeedCal = vsCoil.NumOfSpeeds;
         } else if (SpeedNum < 1) {
             SpeedCal = 1;
         } else {
             SpeedCal = SpeedNum;
         }
-        if ((SpeedNum <= 1) || (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds)) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal);
+
+        if ((SpeedNum <= 1) || (SpeedNum > vsCoil.NumOfSpeeds)) {
+            vsCoil.DesignAirMassFlowRate = vsCoil.MSRatedAirMassFlowRate(SpeedCal);
+            vsCoil.DesignAirVolFlowRate = vsCoil.MSRatedAirVolFlowRate(SpeedCal);
+            vsCoil.DesignWaterMassFlowRate = vsCoil.MSRatedWaterMassFlowRate(SpeedCal);
+            vsCoil.DesignWaterVolFlowRate = vsCoil.MSRatedWaterVolFlowRate(SpeedCal);
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal) * SpeedRatio +
-                (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal - 1);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal) * SpeedRatio +
-                (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal - 1);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal) * SpeedRatio +
-                (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal - 1);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal) * SpeedRatio +
-                (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal - 1);
+            vsCoil.DesignAirMassFlowRate =
+                vsCoil.MSRatedAirMassFlowRate(SpeedCal) * SpeedRatio +
+                (1.0 - SpeedRatio) * vsCoil.MSRatedAirMassFlowRate(SpeedCal - 1);
+            vsCoil.DesignAirVolFlowRate =
+                vsCoil.MSRatedAirVolFlowRate(SpeedCal) * SpeedRatio +
+                (1.0 - SpeedRatio) * vsCoil.MSRatedAirVolFlowRate(SpeedCal - 1);
+            vsCoil.DesignWaterMassFlowRate =
+                vsCoil.MSRatedWaterMassFlowRate(SpeedCal) * SpeedRatio +
+                (1.0 - SpeedRatio) * vsCoil.MSRatedWaterMassFlowRate(SpeedCal - 1);
+            vsCoil.DesignWaterVolFlowRate =
+                vsCoil.MSRatedWaterVolFlowRate(SpeedCal) * SpeedRatio +
+                (1.0 - SpeedRatio) * vsCoil.MSRatedWaterVolFlowRate(SpeedCal - 1);
         }
 
         // Do the Begin Environment initializations
@@ -4260,38 +4135,38 @@ namespace VariableSpeedCoils {
             // Do the initializations to start simulation
 
             // Initialize all report variables to a known state at beginning of simulation
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = 0.0;
-
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
-                WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
-
-                rho = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
+            vsCoil.AirVolFlowRate = 0.0;
+            vsCoil.InletAirDBTemp = 0.0;
+            vsCoil.InletAirHumRat = 0.0;
+            vsCoil.OutletAirDBTemp = 0.0;
+            vsCoil.OutletAirHumRat = 0.0;
+            vsCoil.WaterVolFlowRate = 0.0;
+            vsCoil.WaterMassFlowRate = 0.0;
+            vsCoil.InletWaterTemp = 0.0;
+            vsCoil.InletWaterEnthalpy = 0.0;
+            vsCoil.OutletWaterEnthalpy = 0.0;
+            vsCoil.OutletWaterTemp = 0.0;
+            vsCoil.Power = 0.0;
+            vsCoil.QLoadTotal = 0.0;
+            vsCoil.QSensible = 0.0;
+            vsCoil.QLatent = 0.0;
+            vsCoil.QSource = 0.0;
+            vsCoil.Energy = 0.0;
+            vsCoil.EnergyLoadTotal = 0.0;
+            vsCoil.EnergySensible = 0.0;
+            vsCoil.EnergyLatent = 0.0;
+            vsCoil.EnergySource = 0.0;
+            vsCoil.COP = 0.0;
+            vsCoil.RunFrac = 0.0;
+            vsCoil.PartLoadRatio = 0.0;
+
+            if ((vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) ||
+                (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit)) {
+                WaterInletNode = vsCoil.WaterInletNodeNum;
+
+                rho = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                           .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
-                Cp = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
+                Cp = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                          .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
 
                 //    VarSpeedCoil(DXCoilNum)%DesignWaterMassFlowRate= &
@@ -4299,10 +4174,9 @@ namespace VariableSpeedCoils {
 
                 PlantUtilities::InitComponentNodes(state,
                                                    0.0,
-                                                   state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
-                                                       state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
-                                                   state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
-                                                   state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum);
+                                                   vsCoil.MSRatedWaterMassFlowRate(vsCoil.NumOfSpeeds),
+                                                   vsCoil.WaterInletNodeNum,
+                                                   vsCoil.WaterOutletNodeNum);
 
                 state.dataLoopNodes->Node(WaterInletNode).Temp = 5.0;
                 state.dataLoopNodes->Node(WaterInletNode).Enthalpy = Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
@@ -4310,15 +4184,14 @@ namespace VariableSpeedCoils {
                 state.dataLoopNodes->Node(WaterInletNode).Press = 0.0;
                 state.dataLoopNodes->Node(WaterInletNode).HumRat = 0.0;
 
-                state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Temp = 5.0;
-                state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Enthalpy =
-                    Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
-                state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Quality = 0.0;
-                state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Press = 0.0;
-                state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).HumRat = 0.0;
+                state.dataLoopNodes->Node(vsCoil.WaterOutletNodeNum).Temp = 5.0;
+                state.dataLoopNodes->Node(vsCoil.WaterOutletNodeNum).Enthalpy = Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
+                state.dataLoopNodes->Node(vsCoil.WaterOutletNodeNum).Quality = 0.0;
+                state.dataLoopNodes->Node(vsCoil.WaterOutletNodeNum).Press = 0.0;
+                state.dataLoopNodes->Node(vsCoil.WaterOutletNodeNum).HumRat = 0.0;
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
+            vsCoil.SimFlag = true;
             state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
 
             state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) = false;
@@ -4335,117 +4208,113 @@ namespace VariableSpeedCoils {
 
         // Set water and air inlet nodes
 
-        WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
+        WaterInletNode = vsCoil.WaterInletNodeNum;
 
-        if ((SensLoad != 0.0 || LatentLoad != 0.0) && (state.dataLoopNodes->Node(AirInletNode).MassFlowRate > 0.0)) {
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel) > 0.0) {
-                WaterFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterMassFlowRate /
-                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate * WaterFlowScale;
+        if ((SensLoad != 0.0 || LatentLoad != 0.0) && (state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).MassFlowRate > 0.0)) {
+
+            if (vsCoil.MSRatedWaterMassFlowRate(vsCoil.NormSpedLevel) > 0.0) {
+                WaterFlowScale = vsCoil.RatedWaterMassFlowRate / vsCoil.MSRatedWaterMassFlowRate(vsCoil.NormSpedLevel);
+                vsCoil.WaterMassFlowRate = vsCoil.DesignWaterMassFlowRate * WaterFlowScale;
             } else {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
+                vsCoil.WaterMassFlowRate = 0.0;
             }
 
             if (fanOp == HVAC::FanOp::Continuous) {
                 // continuous fan, cycling compressor
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate;
+                vsCoil.AirMassFlowRate = state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).MassFlowRate;
                 //    VarSpeedCoil(DXCoilNum)%AirMassFlowRate   = VarSpeedCoil(DXCoilNum)%DesignAirVolFlowRate*  &
                 //             PsyRhoAirFnPbTdbW(state, OutBaroPress,Node(AirInletNode)%Temp,Node(AirInletNode)%HumRat)
                 // If air flow is less than 25% rated flow. Then set air flow to the 25% of rated conditions
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate <
-                    0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
+                if (vsCoil.AirMassFlowRate <
+                    0.25 * vsCoil.DesignAirVolFlowRate *
                         Psychrometrics::PsyRhoAirFnPbTdbW(state,
                                                           state.dataEnvrn->OutBaroPress,
-                                                          state.dataLoopNodes->Node(AirInletNode).Temp,
-                                                          state.dataLoopNodes->Node(AirInletNode).HumRat)) {
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
-                        0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
+                                                          state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).Temp,
+                                                          state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).HumRat)) {
+                    vsCoil.AirMassFlowRate =
+                        0.25 * vsCoil.DesignAirVolFlowRate *
                         Psychrometrics::PsyRhoAirFnPbTdbW(state,
                                                           state.dataEnvrn->OutBaroPress,
-                                                          state.dataLoopNodes->Node(AirInletNode).Temp,
-                                                          state.dataLoopNodes->Node(AirInletNode).HumRat);
+                                                          state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).Temp,
+                                                          state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).HumRat);
                 }
             } else { // CYCLIC FAN, NOT CORRECTION, WILL BE PROCESSED IN THE FOLLOWING SUBROUTINES
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate;
+                vsCoil.AirMassFlowRate = state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).MassFlowRate;
             }
 
         } else { // heat pump is off
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = 0.0;
+            vsCoil.WaterMassFlowRate = 0.0;
+            vsCoil.AirMassFlowRate = 0.0;
         }
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
-            (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
+        if ((vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) ||
+            (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit)) {
             PlantUtilities::SetComponentFlowRate(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc);
+                                                 vsCoil.WaterMassFlowRate,
+                                                 vsCoil.WaterInletNodeNum,
+                                                 vsCoil.WaterOutletNodeNum,
+                                                 vsCoil.plantLoc);
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
+            vsCoil.InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
+            vsCoil.InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
+            vsCoil.InletWaterTemp = 0.0;
+            vsCoil.InletWaterEnthalpy = 0.0;
         }
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
+        if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
+            vsCoil.InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
+            vsCoil.InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
         };
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = state.dataLoopNodes->Node(AirInletNode).Temp;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = state.dataLoopNodes->Node(AirInletNode).HumRat;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy = state.dataLoopNodes->Node(AirInletNode).Enthalpy;
+        vsCoil.InletAirDBTemp = state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).Temp;
+        vsCoil.InletAirHumRat = state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).HumRat;
+        vsCoil.InletAirEnthalpy = state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).Enthalpy;
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = state.dataEnvrn->OutBaroPress; // temporary
+        vsCoil.InletAirPressure = state.dataEnvrn->OutBaroPress; // temporary
         // Outlet variables
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
-
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
+        vsCoil.Power = 0.0;
+        vsCoil.QLoadTotal = 0.0;
+        vsCoil.QSensible = 0.0;
+        vsCoil.QLatent = 0.0;
+        vsCoil.QSource = 0.0;
+        vsCoil.QWasteHeat = 0.0;
+        vsCoil.Energy = 0.0;
+        vsCoil.EnergyLoadTotal = 0.0;
+        vsCoil.EnergySensible = 0.0;
+        vsCoil.EnergyLatent = 0.0;
+        vsCoil.EnergySource = 0.0;
+        vsCoil.COP = 0.0;
+
+        vsCoil.OutletAirDBTemp = 0.0;
+        vsCoil.OutletWaterTemp = 0.0;
+        vsCoil.OutletAirHumRat = 0.0;
+        vsCoil.OutletAirEnthalpy = 0.0;
+        vsCoil.OutletWaterEnthalpy = 0.0;
 
         // bug fix, must set zeros to the variables below, otherwise can't pass switch DD test
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
+        vsCoil.CrankcaseHeaterConsumption = 0.0;
+        vsCoil.EvapWaterConsump = 0.0;
+        vsCoil.BasinHeaterConsumption = 0.0;
+        vsCoil.EvapCondPumpElecConsumption = 0.0;
+        vsCoil.CrankcaseHeaterPower = 0.0;
+        vsCoil.DefrostPower = 0.0;
+        vsCoil.DefrostConsumption = 0.0;
+        vsCoil.CondensateVdot = 0.0;
+        vsCoil.CondensateVol = 0.0;
+        vsCoil.QWasteHeat = 0.0;
 
         // clear zeros to HPWH variables
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
-            0.0; // Total electric power consumed by compressor and condenser pump [W]
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingConsumption =
-            0.0; // Total electric consumption by compressor and condenser pump [J]
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergy = 0.0;       // total water heating energy
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = 0.0;   // total WH energy rate
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower = 0.0; // power power
+        vsCoil.ElecWaterHeatingPower = 0.0; // Total electric power consumed by compressor and condenser pump [W]
+        vsCoil.ElecWaterHeatingConsumption = 0.0; // Total electric consumption by compressor and condenser pump [J]
+        vsCoil.TotalHeatingEnergy = 0.0;       // total water heating energy
+        vsCoil.TotalHeatingEnergyRate = 0.0;   // total WH energy rate
+        vsCoil.HPWHCondPumpElecNomPower = 0.0; // power power
 
         state.dataVariableSpeedCoils->VSHPWHHeatingCapacity = 0.0; // Used by Heat Pump:Water Heater object as total water heating capacity [W]
         state.dataVariableSpeedCoils->VSHPWHHeatingCOP = 0.0;      // Used by Heat Pump:Water Heater object as water heating COP [W/W]
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
+
+        vsCoil.OutletWaterTemp = vsCoil.InletWaterTemp;
         state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
     }
 
@@ -4473,7 +4342,7 @@ namespace VariableSpeedCoils {
         static constexpr std::string_view RoutineName("SizeVarSpeedCoil");
         static constexpr std::string_view RoutineNameAlt("SizeHVACWaterToAir");
 
-        auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
         Real64 rhoair = state.dataEnvrn->StdRhoAir;
@@ -4515,8 +4384,8 @@ namespace VariableSpeedCoils {
         Real64 HPInletAirHumRat;      // Rated inlet air humidity ratio for heat pump water heater [kgWater/kgDryAir]
         Real64 HPWHCoolCapacity;      // estimate cooling capacity in HPWH
 
-        int UpperSpeed = varSpeedCoil.NumOfSpeeds;
-        int NormSpeed = varSpeedCoil.NormSpedLevel;
+        int UpperSpeed = vsCoil.NumOfSpeeds;
+        int NormSpeed = vsCoil.NormSpedLevel;
         int PltSizNum = 0;
         bool RatedAirFlowAutoSized = false;
         bool RatedWaterFlowAutoSized = false;
@@ -4553,55 +4422,55 @@ namespace VariableSpeedCoils {
         Real64 DefrostCapacityDes = 0.0;
         Real64 DefrostCapacityUser = 0.0;
 
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-            varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+        if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+            vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
             CurrentObjSubfix = ":WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT";
-        } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
+        } else if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
             CurrentObjSubfix = ":WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
         } else {
             CurrentObjSubfix = ":DX:VARIABLESPEED";
         }
 
-        if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
-            if (varSpeedCoil.RatedAirVolFlowRate == Constant::AutoCalculate) {
-                varSpeedCoil.RatedAirVolFlowRate =
-                    varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedAirVolFlowRate(NormSpeed) / varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00005035;
-                varSpeedCoil.AirVolFlowAutoSized = true;
+        if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
+            if (vsCoil.RatedAirVolFlowRate == Constant::AutoCalculate) {
+                vsCoil.RatedAirVolFlowRate =
+                    vsCoil.RatedCapWH * vsCoil.MSRatedAirVolFlowRate(NormSpeed) / vsCoil.MSRatedTotCap(NormSpeed); // 0.00005035;
+                vsCoil.AirVolFlowAutoSized = true;
             }
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
-                state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, varSpeedCoil.AirVolFlowAutoSized);
+            ReportCoilSelection::setCoilAirFlow(
+                state, vsCoil.Name, vsCoil.coilType, vsCoil.RatedAirVolFlowRate, vsCoil.AirVolFlowAutoSized);
 
-            if (varSpeedCoil.RatedWaterVolFlowRate == Constant::AutoCalculate) {
-                varSpeedCoil.RatedHPWHCondWaterFlow = varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) /
-                                                      varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00000004487;
-                varSpeedCoil.RatedWaterVolFlowRate = varSpeedCoil.RatedHPWHCondWaterFlow;
-                varSpeedCoil.WaterVolFlowAutoSized = true;
+            if (vsCoil.RatedWaterVolFlowRate == Constant::AutoCalculate) {
+                vsCoil.RatedHPWHCondWaterFlow = vsCoil.RatedCapWH * vsCoil.MSRatedWaterVolFlowRate(NormSpeed) /
+                                                      vsCoil.MSRatedTotCap(NormSpeed); // 0.00000004487;
+                vsCoil.RatedWaterVolFlowRate = vsCoil.RatedHPWHCondWaterFlow;
+                vsCoil.WaterVolFlowAutoSized = true;
             }
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(state,
-                                                                                          varSpeedCoil.Name,
-                                                                                          varSpeedCoil.VarSpeedCoilType,
-                                                                                          varSpeedCoil.RatedWaterVolFlowRate,
-                                                                                          varSpeedCoil.WaterVolFlowAutoSized,
+            ReportCoilSelection::setCoilWaterFlowPltSizNum(state,
+                                                                                          vsCoil.Name,
+                                                                                          vsCoil.coilType,
+                                                                                          vsCoil.RatedWaterVolFlowRate,
+                                                                                          vsCoil.WaterVolFlowAutoSized,
                                                                                           -999,
-                                                                                          varSpeedCoil.plantLoc.loopNum);
+                                                                                          vsCoil.plantLoc.loopNum);
         }
 
-        if (varSpeedCoil.RatedAirVolFlowRate == DataSizing::AutoSize) {
+        if (vsCoil.RatedAirVolFlowRate == DataSizing::AutoSize) {
             RatedAirFlowAutoSized = true;
         }
 
         if (state.dataSize->CurSysNum > 0) {
             if (!RatedAirFlowAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
                 HardSizeNoDesRunAirFlow = true;
-                if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
+                if (vsCoil.RatedAirVolFlowRate > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                 varSpeedCoil.Name,
+                                                 format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                 vsCoil.Name,
                                                  "User-Specified Rated Air Flow Rate [m3/s]",
-                                                 varSpeedCoil.RatedAirVolFlowRate);
+                                                 vsCoil.RatedAirVolFlowRate);
                 }
             } else {
-                CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
+                CheckSysSizing(state, format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix), vsCoil.Name);
                 if (state.dataSize->CurOASysNum > 0 && state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum > -1) {
                     auto const &thisAirloopDOAS =
                         state.dataAirLoopHVACDOAS->airloopDOAS[state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum];
@@ -4619,15 +4488,15 @@ namespace VariableSpeedCoils {
         if (state.dataSize->CurZoneEqNum > 0) {
             if (!RatedAirFlowAutoSized && !SizingDesRunThisZone) { // Simulation continue
                 HardSizeNoDesRunAirFlow = true;
-                if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
+                if (vsCoil.RatedAirVolFlowRate > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                 varSpeedCoil.Name,
+                                                 format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                 vsCoil.Name,
                                                  "User-Specified Rated Air Flow Rate [m3/s]",
-                                                 varSpeedCoil.RatedAirVolFlowRate);
+                                                 vsCoil.RatedAirVolFlowRate);
                 }
             } else {
-                CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
+                CheckZoneSizing(state, format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix), vsCoil.Name);
                 RatedAirVolFlowRateDes = max(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesCoolVolFlow,
                                              state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatVolFlow);
                 if (RatedAirVolFlowRateDes < HVAC::SmallAirVolFlow) {
@@ -4636,54 +4505,56 @@ namespace VariableSpeedCoils {
             }
         }
 
-        if (RatedAirFlowAutoSized) varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
+        if (RatedAirFlowAutoSized) vsCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
 
         RatedCapCoolTotalAutoSized = false;
         RatedCapCoolSensAutoSized = false;
 
         // size rated total cooling capacity
         IsAutoSize = false;
-        if (varSpeedCoil.RatedCapCoolTotal == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-                                                                       varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
+        if (vsCoil.RatedCapCoolTotal == DataSizing::AutoSize &&
+            (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+             vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed)) {
             RatedCapCoolTotalAutoSized = true;
         }
+
         if (SizingDesRunThisZone || SizingDesRunThisAirSys) HardSizeNoDesRun = false;
         if (state.dataSize->CurSysNum > 0) {
             if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
                 HardSizeNoDesRun = true;
-                if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
+                if (vsCoil.RatedCapCoolTotal > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                 varSpeedCoil.Name,
+                                                 format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                 vsCoil.Name,
                                                  "User-Specified Rated Total Cooling Capacity [W]",
-                                                 varSpeedCoil.RatedCapCoolTotal);
+                                                 vsCoil.RatedCapCoolTotal);
                 }
             } else {
-                CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
+                CheckSysSizing(state, format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix), vsCoil.Name);
                 if (state.dataSize->CurOASysNum > 0 && state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum > -1) {
                     auto const &thisAirloopDOAS =
                         state.dataAirLoopHVACDOAS->airloopDOAS[state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum];
-                    VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
+                    VolFlowRate = vsCoil.RatedAirVolFlowRate;
                     MixTemp = thisAirloopDOAS.SizingCoolOATemp;
                     SupTemp = thisAirloopDOAS.PrecoolTemp;
                     MixHumRat = thisAirloopDOAS.SizingCoolOAHumRat;
                     SupHumRat = thisAirloopDOAS.PrecoolHumRat;
                     RatedCapCoolTotalDes = VolFlowRate * state.dataEnvrn->StdRhoAir *
                                            (Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat) - Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat));
-                    if (varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel) > 0) {
+                    if (vsCoil.MSCCapFTemp(vsCoil.NormSpedLevel) > 0) {
                         MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
-                        if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
+                        if (vsCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
                             RatedSourceTempCool = thisAirloopDOAS.SizingCoolOATemp;
                         } else {
-                            RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
+                            RatedSourceTempCool = VariableSpeedCoils::GetCoilRatedSourceTemp(state, DXCoilNum);
                         }
                         TotCapTempModFac =
-                            Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
+                            Curve::CurveValue(state, vsCoil.MSCCapFTemp(vsCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
                         RatedCapCoolTotalDes /= TotCapTempModFac;
                     }
                 } else {
                     auto const &finalSysSizing = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum);
-                    VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
+                    VolFlowRate = vsCoil.RatedAirVolFlowRate;
                     if (VolFlowRate >= HVAC::SmallAirVolFlow) {
                         if (state.dataSize->CurOASysNum > 0) { // coil is in the OA stream
                             MixTemp = finalSysSizing.OutTempAtCoolPeak;
@@ -4722,13 +4593,13 @@ namespace VariableSpeedCoils {
                             SupTemp -= FanCoolLoad / (CpAir * rhoair * VolFlowRate);
                         }
                         MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
-                        if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
+                        if (vsCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
                             RatedSourceTempCool = OutTemp;
                         } else {
-                            RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
+                            RatedSourceTempCool = VariableSpeedCoils::GetCoilRatedSourceTemp(state, DXCoilNum);
                         }
                         TotCapTempModFac =
-                            Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
+                            Curve::CurveValue(state, vsCoil.MSCCapFTemp(vsCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
 
                         //       The mixed air temp for zone equipment without an OA mixer is 0.
                         //       This test avoids a negative capacity until a solution can be found.
@@ -4752,17 +4623,17 @@ namespace VariableSpeedCoils {
         } else if (state.dataSize->CurZoneEqNum > 0) {
             if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisZone) { // Simulation continue
                 HardSizeNoDesRun = true;
-                if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
+                if (vsCoil.RatedCapCoolTotal > 0.0) {
                     BaseSizer::reportSizerOutput(state,
-                                                 format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                 varSpeedCoil.Name,
+                                                 format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                 vsCoil.Name,
                                                  "User-Specified Rated Total Cooling Capacity [W]",
-                                                 varSpeedCoil.RatedCapCoolTotal);
+                                                 vsCoil.RatedCapCoolTotal);
                 }
             } else {
-                CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
+                CheckZoneSizing(state, format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix), vsCoil.Name);
                 auto const &finalZoneSizing = state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum);
-                VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
+                VolFlowRate = vsCoil.RatedAirVolFlowRate;
                 if (VolFlowRate >= HVAC::SmallAirVolFlow) {
                     if (state.dataSize->ZoneEqDXCoil) {
                         if (state.dataSize->ZoneEqSizing(state.dataSize->CurZoneEqNum).OAVolFlow > 0.0) {
@@ -4800,13 +4671,13 @@ namespace VariableSpeedCoils {
                     }
 
                     MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
-                    if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
+                    if (vsCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
                         RatedSourceTempCool = OutTemp;
                     } else {
-                        RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
+                        RatedSourceTempCool = VariableSpeedCoils::GetCoilRatedSourceTemp(state, DXCoilNum);
                     }
                     TotCapTempModFac =
-                        Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
+                        Curve::CurveValue(state, vsCoil.MSCCapFTemp(vsCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
 
                     //       The mixed air temp for zone equipment without an OA mixer is 0.
                     //       This test avoids a negative capacity until a solution can be found.
@@ -4831,39 +4702,39 @@ namespace VariableSpeedCoils {
         }
         if (!HardSizeNoDesRun) {
             if (RatedCapCoolTotalAutoSized) {
-                varSpeedCoil.RatedCapCoolTotal = RatedCapCoolTotalDes;
+                vsCoil.RatedCapCoolTotal = RatedCapCoolTotalDes;
                 BaseSizer::reportSizerOutput(state,
-                                             format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                             varSpeedCoil.Name,
+                                             format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                             vsCoil.Name,
                                              "Design Size Rated Total Cooling Capacity [W]",
-                                             varSpeedCoil.RatedCapCoolTotal);
+                                             vsCoil.RatedCapCoolTotal);
                 OutputReportPredefined::PreDefTableEntry(
-                    state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
+                    state, state.dataOutRptPredefined->pdchCoolCoilTotCap, vsCoil.Name, vsCoil.RatedCapCoolTotal);
                 OutputReportPredefined::PreDefTableEntry(state,
                                                          state.dataOutRptPredefined->pdchCoolCoilLatCap,
-                                                         varSpeedCoil.Name,
-                                                         varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
-                if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
+                                                         vsCoil.Name,
+                                                         vsCoil.RatedCapCoolTotal - vsCoil.RatedCapCoolSens);
+                if (vsCoil.RatedCapCoolTotal != 0.0) {
                     OutputReportPredefined::PreDefTableEntry(state,
                                                              state.dataOutRptPredefined->pdchCoolCoilSHR,
-                                                             varSpeedCoil.Name,
-                                                             varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
+                                                             vsCoil.Name,
+                                                             vsCoil.RatedCapCoolSens / vsCoil.RatedCapCoolTotal);
                     OutputReportPredefined::PreDefTableEntry(
-                        state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(NormSpeed));
+                        state, state.dataOutRptPredefined->pdchCoolCoilNomEff, vsCoil.Name, vsCoil.MSRatedCOP(NormSpeed));
                 } else {
-                    OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, varSpeedCoil.Name, 0.0);
-                    OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, 0.0);
+                    OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, vsCoil.Name, 0.0);
+                    OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilNomEff, vsCoil.Name, 0.0);
                 }
                 OutputReportPredefined::addFootNoteSubTable(
                     state,
                     state.dataOutRptPredefined->pdstCoolCoil,
                     "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
             } else {
-                if (varSpeedCoil.RatedCapCoolTotal > 0.0 && RatedCapCoolTotalDes > 0.0) {
-                    RatedCapCoolTotalUser = varSpeedCoil.RatedCapCoolTotal;
+                if (vsCoil.RatedCapCoolTotal > 0.0 && RatedCapCoolTotalDes > 0.0) {
+                    RatedCapCoolTotalUser = vsCoil.RatedCapCoolTotal;
                     BaseSizer::reportSizerOutput(state,
-                                                 format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                 varSpeedCoil.Name,
+                                                 format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                 vsCoil.Name,
                                                  "Design Size Rated Total Cooling Capacity [W]",
                                                  RatedCapCoolTotalDes,
                                                  "User-Specified Rated Total Cooling Capacity [W]",
@@ -4873,9 +4744,9 @@ namespace VariableSpeedCoils {
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(state,
                                         format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
-                                               varSpeedCoil.CoolHeatType,
+                                               vsCoil.CoolHeatType,
                                                CurrentObjSubfix));
-                            ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
+                            ShowContinueError(state, format("Coil Name = {}", vsCoil.Name));
                             ShowContinueError(state, format("User-Specified Rated Total Cooling Capacity of {:.2R} [W]", RatedCapCoolTotalUser));
                             ShowContinueError(state,
                                               format("differs from Design Size Rated Total Cooling Capacity of {:.2R} [W]", RatedCapCoolTotalDes));
@@ -4886,47 +4757,43 @@ namespace VariableSpeedCoils {
                 }
             }
 
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(
-                state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixHumRat);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupTemp);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(
-                state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupHumRat);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
-                state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, RatedAirFlowAutoSized);
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(state,
-                                                                                       varSpeedCoil.Name,
-                                                                                       varSpeedCoil.VarSpeedCoilType,
-                                                                                       RatedCapCoolTotalDes,
-                                                                                       RatedCapCoolTotalAutoSized,
-                                                                                       state.dataSize->CurSysNum,
-                                                                                       state.dataSize->CurZoneEqNum,
-                                                                                       state.dataSize->CurOASysNum,
-                                                                                       0.0, // no fan load included in sizing
-                                                                                       TotCapTempModFac,
-                                                                                       -999.0,
-                                                                                       -999.0); // VS model doesn't limit, double check
+            ReportCoilSelection::setCoilEntAirTemp(state, vsCoil.Name, vsCoil.coilType, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
+            ReportCoilSelection::setCoilEntAirHumRat(state, vsCoil.Name, vsCoil.coilType, MixHumRat);
+            ReportCoilSelection::setCoilLvgAirTemp(state, vsCoil.Name, vsCoil.coilType, SupTemp);
+            ReportCoilSelection::setCoilLvgAirHumRat(state, vsCoil.Name, vsCoil.coilType, SupHumRat);
+            ReportCoilSelection::setCoilAirFlow(state, vsCoil.Name, vsCoil.coilType, vsCoil.RatedAirVolFlowRate, RatedAirFlowAutoSized);
+            ReportCoilSelection::setCoilCoolingCapacity(state,
+                                               vsCoil.Name,
+                                               vsCoil.coilType,
+                                               RatedCapCoolTotalDes,
+                                               RatedCapCoolTotalAutoSized,
+                                               state.dataSize->CurSysNum,
+                                               state.dataSize->CurZoneEqNum,
+                                               state.dataSize->CurOASysNum,
+                                               0.0, // no fan load included in sizing
+                                               TotCapTempModFac,
+                                               -999.0,
+                                               -999.0); // VS model doesn't limit, double check
         }
 
         // Set the global DX cooling coil capacity variable for use by other objects
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-            varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            state.dataSize->DXCoolCap = varSpeedCoil.RatedCapCoolTotal;
+        if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+            vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            state.dataSize->DXCoolCap = vsCoil.RatedCapCoolTotal;
         }
 
         // size rated heating capacity
-        if (varSpeedCoil.RatedCapHeat == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                                                                  varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
+        if (vsCoil.RatedCapHeat == DataSizing::AutoSize && (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+                                                            vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed)) {
             RatedCapHeatAutoSized = true;
         }
         //   simply set heating capacity equal to the cooling capacity
         // VarSpeedCoil(DXCoilNum)%RatedCapHeat = DXCoolCap
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-            varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-            if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
-                RatedCapHeatDes = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal;
-                varSpeedCoil.RatedCapCoolTotal = RatedCapHeatDes; // AVOID BEING ZERO
+        if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+            vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+            if (vsCoil.CompanionCoolingCoilNum > 0) {
+                RatedCapHeatDes = state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).RatedCapCoolTotal;
+                vsCoil.RatedCapCoolTotal = RatedCapHeatDes; // AVOID BEING ZERO
             } else {
                 RatedCapHeatDes = state.dataSize->DXCoolCap; // previous code, can be risky
             }
@@ -4934,7 +4801,7 @@ namespace VariableSpeedCoils {
             if (RatedCapHeatAutoSized) {
                 if (RatedCapHeatDes == DataSizing::AutoSize) {
                     ShowWarningError(
-                        state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
+                        state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", vsCoil.CoolHeatType, vsCoil.Name));
                     ShowContinueError(state,
                                       format("{}: Heating coil could not be autosized since cooling coil was not previously sized.", RoutineName));
                     ShowContinueError(state, "... Cooling coil must be upstream of heating coil.");
@@ -4944,44 +4811,45 @@ namespace VariableSpeedCoils {
             if (RatedCapHeatDes < HVAC::SmallLoad) {
                 RatedCapHeatDes = 0.0;
             }
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(state,
-                                                                                       varSpeedCoil.Name,
-                                                                                       varSpeedCoil.VarSpeedCoilType,
-                                                                                       RatedCapHeatDes,
-                                                                                       RatedCapHeatAutoSized,
-                                                                                       state.dataSize->CurSysNum,
-                                                                                       state.dataSize->CurZoneEqNum,
-                                                                                       state.dataSize->CurOASysNum,
-                                                                                       0.0,
-                                                                                       1.0,
-                                                                                       -999.0,
-                                                                                       -999.0);
+
+            ReportCoilSelection::setCoilHeatingCapacity(state,
+                                               vsCoil.Name,
+                                               vsCoil.coilType,
+                                               RatedCapHeatDes,
+                                               RatedCapHeatAutoSized,
+                                               state.dataSize->CurSysNum,
+                                               state.dataSize->CurZoneEqNum,
+                                               state.dataSize->CurOASysNum,
+                                               0.0,
+                                               1.0,
+                                               -999.0,
+                                               -999.0);
         }
         if (RatedCapHeatAutoSized) {
-            varSpeedCoil.RatedCapHeat = RatedCapHeatDes;
+            vsCoil.RatedCapHeat = RatedCapHeatDes;
             BaseSizer::reportSizerOutput(state,
-                                         format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                         varSpeedCoil.Name,
+                                         format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                         vsCoil.Name,
                                          "Design Size Nominal Heating Capacity [W]",
                                          RatedCapHeatDes);
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, varSpeedCoil.Name, varSpeedCoil.RatedCapHeat);
-            if (varSpeedCoil.RatedCapHeat != 0.0) {
+                state, state.dataOutRptPredefined->pdchHeatCoilNomCap, vsCoil.Name, vsCoil.RatedCapHeat);
+            if (vsCoil.RatedCapHeat != 0.0) {
                 OutputReportPredefined::PreDefTableEntry(
-                    state, state.dataOutRptPredefined->pdchHeatCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(NormSpeed));
+                    state, state.dataOutRptPredefined->pdchHeatCoilNomEff, vsCoil.Name, vsCoil.MSRatedCOP(NormSpeed));
             } else {
-                OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, varSpeedCoil.Name, 0.0);
+                OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, vsCoil.Name, 0.0);
             }
             OutputReportPredefined::addFootNoteSubTable(
                 state,
                 state.dataOutRptPredefined->pdstHeatCoil,
                 "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
         } else {
-            if (varSpeedCoil.RatedCapHeat > 0.0 && RatedCapHeatDes > 0.0) {
-                RatedCapHeatUser = varSpeedCoil.RatedCapHeat;
+            if (vsCoil.RatedCapHeat > 0.0 && RatedCapHeatDes > 0.0) {
+                RatedCapHeatUser = vsCoil.RatedCapHeat;
                 BaseSizer::reportSizerOutput(state,
-                                             format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                             varSpeedCoil.Name,
+                                             format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                             vsCoil.Name,
                                              "Design Size Nominal Heating Capacity [W]",
                                              RatedCapHeatDes,
                                              "User-Specified Nominal Heating Capacity [W]",
@@ -4990,8 +4858,8 @@ namespace VariableSpeedCoils {
                     if ((std::abs(RatedCapHeatDes - RatedCapHeatUser) / RatedCapHeatUser) > state.dataSize->AutoVsHardSizingThreshold) {
                         ShowMessage(
                             state,
-                            format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix));
-                        ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
+                            format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", vsCoil.CoolHeatType, CurrentObjSubfix));
+                        ShowContinueError(state, format("Coil Name = {}", vsCoil.Name));
                         ShowContinueError(state, format("User-Specified Rated Total Heating Capacity of {:.2R} [W]", RatedCapHeatUser));
                         ShowContinueError(state, format("differs from Design Size Rated Total Heating Capacity of {:.2R} [W]", RatedCapHeatDes));
                         ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
@@ -5004,25 +4872,25 @@ namespace VariableSpeedCoils {
         // FORCE BACK TO THE RATED AIR FLOW RATE WITH THE SAME RATIO DEFINED BY THE CATALOG DATA
         if (!HardSizeNoDesRunAirFlow) {
             if ((RatedCapCoolTotalAutoSized) && (RatedAirFlowAutoSized)) {
-                RatedAirVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
+                RatedAirVolFlowRateDes = vsCoil.RatedCapCoolTotal * vsCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
             } else if ((RatedCapHeatAutoSized) && (RatedAirFlowAutoSized)) {
-                RatedAirVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
+                RatedAirVolFlowRateDes = vsCoil.RatedCapHeat * vsCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
             }
 
             // write the air flow sizing output
             if (RatedAirFlowAutoSized) {
-                varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
+                vsCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
                 BaseSizer::reportSizerOutput(state,
-                                             format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                             varSpeedCoil.Name,
+                                             format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                             vsCoil.Name,
                                              "Design Size Rated Air Flow Rate [m3/s]",
                                              RatedAirVolFlowRateDes);
             } else {
-                if (varSpeedCoil.RatedAirVolFlowRate > 0.0 && RatedAirVolFlowRateDes > 0.0) {
-                    RatedAirVolFlowRateUser = varSpeedCoil.RatedAirVolFlowRate;
+                if (vsCoil.RatedAirVolFlowRate > 0.0 && RatedAirVolFlowRateDes > 0.0) {
+                    RatedAirVolFlowRateUser = vsCoil.RatedAirVolFlowRate;
                     BaseSizer::reportSizerOutput(state,
-                                                 format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                 varSpeedCoil.Name,
+                                                 format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                 vsCoil.Name,
                                                  "Design Size Rated Air Flow Rate [m3/s]",
                                                  RatedAirVolFlowRateDes,
                                                  "User-Specified Rated Air Flow Rate [m3/s]",
@@ -5032,9 +4900,9 @@ namespace VariableSpeedCoils {
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(state,
                                         format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
-                                               varSpeedCoil.CoolHeatType,
+                                               vsCoil.CoolHeatType,
                                                CurrentObjSubfix));
-                            ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
+                            ShowContinueError(state, format("Coil Name = {}", vsCoil.Name));
                             ShowContinueError(state, format("User-Specified Rated Air Flow Rate of {:.5R} [m3/s]", RatedAirVolFlowRateUser));
                             ShowContinueError(state, format("differs from Design Size Rated Air Flow Rate of {:.5R} [m3/s]", RatedAirVolFlowRateDes));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
@@ -5043,262 +4911,261 @@ namespace VariableSpeedCoils {
                     }
                 }
             }
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
-                state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, RatedAirVolFlowRateDes, RatedAirFlowAutoSized);
+            ReportCoilSelection::setCoilAirFlow(state, vsCoil.Name, vsCoil.coilType, RatedAirVolFlowRateDes, RatedAirFlowAutoSized);
         }
 
         // Check that heat pump heating capacity is within 20% of cooling capacity. Check only for heating coil and report both.
-        if ((varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-             varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
-            varSpeedCoil.CompanionCoolingCoilNum > 0) {
+        if ((vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+             vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) &&
+            vsCoil.CompanionCoolingCoilNum > 0) {
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal > 0.0) {
+            if (state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).RatedCapCoolTotal > 0.0) {
 
-                if (std::abs(state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal -
-                             varSpeedCoil.RatedCapHeat) /
-                        state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal >
+                if (std::abs(state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).RatedCapCoolTotal -
+                             vsCoil.RatedCapHeat) /
+                        state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).RatedCapCoolTotal >
                     0.2) {
 
                     ShowWarningError(
-                        state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
+                        state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", vsCoil.CoolHeatType, vsCoil.Name));
                     ShowContinueError(state,
                                       format("...used with COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"",
-                                             state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).CoolHeatType,
-                                             state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).Name));
+                                             state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).CoolHeatType,
+                                             state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).Name));
                     ShowContinueError(state, "...heating capacity is disproportionate (> 20% different) to total cooling capacity");
-                    ShowContinueError(state, format("...heating capacity = {:.3T} W", varSpeedCoil.RatedCapHeat));
+                    ShowContinueError(state, format("...heating capacity = {:.3T} W", vsCoil.RatedCapHeat));
                     ShowContinueError(state,
                                       format("...cooling capacity = {:.3T} W",
-                                             state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal));
+                                             state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).RatedCapCoolTotal));
                 }
             }
         }
 
         // ASSIGN CAPACITY
-        switch (varSpeedCoil.VSCoilType) {
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
-        case HVAC::Coil_CoolingAirToAirVariableSpeed: {
-            varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
+        switch (vsCoil.coilType) {
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit:
+        case HVAC::CoilType::CoolingDXVariableSpeed: {
+            vsCoil.MSRatedTotCap(UpperSpeed) = vsCoil.RatedCapCoolTotal / vsCoil.MSRatedPercentTotCap(NormSpeed);
         } break;
-        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
-        case HVAC::Coil_HeatingAirToAirVariableSpeed: {
-            varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapHeat / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit:
+        case HVAC::CoilType::HeatingDXVariableSpeed: {
+            vsCoil.MSRatedTotCap(UpperSpeed) = vsCoil.RatedCapHeat / vsCoil.MSRatedPercentTotCap(NormSpeed);
         } break;
-        case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
-            varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapWH / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
+        case HVAC::CoilType::WaterHeatingAWHPVariableSpeed: {
+            vsCoil.MSRatedTotCap(UpperSpeed) = vsCoil.RatedCapWH / vsCoil.MSRatedPercentTotCap(NormSpeed);
         } break;
         }
 
-        if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
+        if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
             HPInletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(
-                state, varSpeedCoil.WHRatedInletDBTemp, varSpeedCoil.WHRatedInletWBTemp, state.dataEnvrn->StdBaroPress, RoutineName);
+                state, vsCoil.WHRatedInletDBTemp, vsCoil.WHRatedInletWBTemp, state.dataEnvrn->StdBaroPress, RoutineName);
 
-            for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
-                varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
-                varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
-                varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
+            for (Mode = vsCoil.NumOfSpeeds; Mode >= 1; --Mode) {
+                vsCoil.MSRatedTotCap(Mode) = vsCoil.MSRatedTotCap(UpperSpeed) * vsCoil.MSRatedPercentTotCap(Mode);
+                vsCoil.MSRatedAirVolFlowRate(Mode) = vsCoil.MSRatedTotCap(Mode) * vsCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
+                vsCoil.MSRatedAirMassFlowRate(Mode) = vsCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
                 // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
-                varSpeedCoil.EvapCondAirFlow(Mode) = 0.0;
+                vsCoil.EvapCondAirFlow(Mode) = 0.0;
             }
         } else {
             // HPWH, the mass flow rate will be updated by a revised entering air density
 
-            if (varSpeedCoil.MSHPDesignSpecIndex > -1 && state.dataUnitarySystems->designSpecMSHP.size() > 0) {
-                if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-                    varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-                    if (state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].numOfSpeedCooling != varSpeedCoil.NumOfSpeeds) {
+            if (vsCoil.MSHPDesignSpecIndex > -1 && state.dataUnitarySystems->designSpecMSHP.size() > 0) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+                    vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+                    if (state.dataUnitarySystems->designSpecMSHP[vsCoil.MSHPDesignSpecIndex].numOfSpeedCooling != vsCoil.NumOfSpeeds) {
                         ShowFatalError(state,
                                        format("COIL:{} = {}{} number of speeds not equal to number of speed specified in "
                                               "UnitarySystemPerformance:Multispeed object.",
-                                              varSpeedCoil.CoolHeatType,
+                                              vsCoil.CoolHeatType,
                                               CurrentObjSubfix,
-                                              varSpeedCoil.Name));
+                                              vsCoil.Name));
                     } else {
-                        for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
-                            varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
-                                varSpeedCoil.RatedAirVolFlowRate *
-                                state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].coolingVolFlowRatio[Mode - 1];
-                            varSpeedCoil.MSRatedTotCap(Mode) =
-                                varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
-                            varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
+                        for (Mode = vsCoil.NumOfSpeeds; Mode >= 1; --Mode) {
+                            vsCoil.MSRatedAirVolFlowRate(Mode) =
+                                vsCoil.RatedAirVolFlowRate *
+                                state.dataUnitarySystems->designSpecMSHP[vsCoil.MSHPDesignSpecIndex].coolingVolFlowRatio[Mode - 1];
+                            vsCoil.MSRatedTotCap(Mode) =
+                                vsCoil.MSRatedAirVolFlowRate(Mode) / vsCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
+                            vsCoil.MSRatedAirMassFlowRate(Mode) = vsCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
                             // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
-                            varSpeedCoil.EvapCondAirFlow(Mode) =
-                                varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
+                            vsCoil.EvapCondAirFlow(Mode) =
+                                vsCoil.MSRatedTotCap(Mode) * vsCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
                         }
                     }
-                } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                           varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-                    if (state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].numOfSpeedHeating != varSpeedCoil.NumOfSpeeds) {
+                } else if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+                           vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+                    if (state.dataUnitarySystems->designSpecMSHP[vsCoil.MSHPDesignSpecIndex].numOfSpeedHeating != vsCoil.NumOfSpeeds) {
                         ShowFatalError(state,
                                        format("COIL:{}{} = \"{}\" number of speeds not equal to number of speed specified in "
                                               "UnitarySystemPerformance:Multispeed object.",
-                                              varSpeedCoil.CoolHeatType,
+                                              vsCoil.CoolHeatType,
                                               CurrentObjSubfix,
-                                              varSpeedCoil.Name));
+                                              vsCoil.Name));
                     } else {
-                        for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
-                            varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
-                                varSpeedCoil.RatedAirVolFlowRate *
-                                state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].heatingVolFlowRatio[Mode - 1];
-                            varSpeedCoil.MSRatedTotCap(Mode) =
-                                varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
-                            varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
+                        for (Mode = vsCoil.NumOfSpeeds; Mode >= 1; --Mode) {
+                            vsCoil.MSRatedAirVolFlowRate(Mode) =
+                                vsCoil.RatedAirVolFlowRate *
+                                state.dataUnitarySystems->designSpecMSHP[vsCoil.MSHPDesignSpecIndex].heatingVolFlowRatio[Mode - 1];
+                            vsCoil.MSRatedTotCap(Mode) =
+                                vsCoil.MSRatedAirVolFlowRate(Mode) / vsCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
+                            vsCoil.MSRatedAirMassFlowRate(Mode) = vsCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
                             // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
-                            varSpeedCoil.EvapCondAirFlow(Mode) =
-                                varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
+                            vsCoil.EvapCondAirFlow(Mode) =
+                                vsCoil.MSRatedTotCap(Mode) * vsCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
                         }
                     }
                 }
             } else {
-                for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
-                    varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
-                    varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
-                    varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
+                for (Mode = vsCoil.NumOfSpeeds; Mode >= 1; --Mode) {
+                    vsCoil.MSRatedTotCap(Mode) = vsCoil.MSRatedTotCap(UpperSpeed) * vsCoil.MSRatedPercentTotCap(Mode);
+                    vsCoil.MSRatedAirVolFlowRate(Mode) = vsCoil.MSRatedTotCap(Mode) * vsCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
+                    vsCoil.MSRatedAirMassFlowRate(Mode) = vsCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
                     // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
-                    varSpeedCoil.EvapCondAirFlow(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
+                    vsCoil.EvapCondAirFlow(Mode) = vsCoil.MSRatedTotCap(Mode) * vsCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
                 }
             }
         }
 
         // size rated power
-        switch (varSpeedCoil.VSCoilType) {
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
-        case HVAC::Coil_CoolingAirToAirVariableSpeed: {
-            varSpeedCoil.RatedCOPCool = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
-            varSpeedCoil.RatedPowerCool = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.RatedCOPCool;
+        switch (vsCoil.coilType) {
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit:
+        case HVAC::CoilType::CoolingDXVariableSpeed: {
+            vsCoil.RatedCOPCool = vsCoil.MSRatedCOP(vsCoil.NormSpedLevel);
+            vsCoil.RatedPowerCool = vsCoil.RatedCapCoolTotal / vsCoil.RatedCOPCool;
         } break;
-        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
-        case HVAC::Coil_HeatingAirToAirVariableSpeed: {
-            varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
-            varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapHeat / varSpeedCoil.RatedCOPHeat;
-            varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapHeat;
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit:
+        case HVAC::CoilType::HeatingDXVariableSpeed: {
+            vsCoil.RatedCOPHeat = vsCoil.MSRatedCOP(vsCoil.NormSpedLevel);
+            vsCoil.RatedPowerHeat = vsCoil.RatedCapHeat / vsCoil.RatedCOPHeat;
+            vsCoil.RatedCapCoolTotal = vsCoil.RatedCapHeat;
         } break;
-        case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
-            varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
-            varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapWH / varSpeedCoil.RatedCOPHeat;
-            varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapWH * (1.0 - 1.0 / varSpeedCoil.RatedCOPHeat);
+        case HVAC::CoilType::WaterHeatingAWHPVariableSpeed: {
+            vsCoil.RatedCOPHeat = vsCoil.MSRatedCOP(vsCoil.NormSpedLevel);
+            vsCoil.RatedPowerHeat = vsCoil.RatedCapWH / vsCoil.RatedCOPHeat;
+            vsCoil.RatedCapCoolTotal = vsCoil.RatedCapWH * (1.0 - 1.0 / vsCoil.RatedCOPHeat);
         } break;
         }
 
         // Size water volumetric flow rate
-        if ((varSpeedCoil.RatedWaterVolFlowRate == DataSizing::AutoSize) &&
-            (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-             varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) {
+        if ((vsCoil.RatedWaterVolFlowRate == DataSizing::AutoSize) &&
+            (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+             vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit)) {
             RatedWaterFlowAutoSized = true;
         }
 
         //   WSHP condenser can be on either a plant loop or condenser loop. Test each to find plant sizing number.
         //   first check to see if coil is connected to a plant loop, no warning on this CALL
         if (RatedWaterFlowAutoSized) {
-            if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Water)
+            if (vsCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Water)
                 PltSizNum = PlantUtilities::MyPlantSizingIndex(state,
-                                                               format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                               varSpeedCoil.Name,
-                                                               varSpeedCoil.WaterInletNodeNum,
-                                                               varSpeedCoil.WaterOutletNodeNum,
+                                                               format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                               vsCoil.Name,
+                                                               vsCoil.WaterInletNodeNum,
+                                                               vsCoil.WaterOutletNodeNum,
                                                                ErrorsFound,
                                                                false);
 
             if (PltSizNum > 0) {
-                rho = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
+                rho = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                           .glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
-                cp = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
+                cp = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                          .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
 
-                if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                    varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+                    vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
 
-                    RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
+                    RatedWaterVolFlowRateDes = vsCoil.RatedCapHeat / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
 
-                    state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
+                    ReportCoilSelection::setCoilLvgWaterTemp(
                         state,
-                        varSpeedCoil.Name,
-                        varSpeedCoil.VarSpeedCoilType,
+                        vsCoil.Name,
+                        vsCoil.coilType,
                         state.dataSize->PlantSizData(PltSizNum).ExitTemp +
                             state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
 
-                } else if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-                           varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                } else if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+                           vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
 
                     //       use companion heating coil capacity to calculate volumetric flow rate
-                    if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
-                        SystemCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapHeat;
+                    if (vsCoil.CompanionCoolingCoilNum > 0) {
+                        SystemCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(vsCoil.CompanionCoolingCoilNum).RatedCapHeat;
                     } else {
-                        SystemCapacity = varSpeedCoil.RatedCapCoolTotal;
+                        SystemCapacity = vsCoil.RatedCapCoolTotal;
                     }
 
                     RatedWaterVolFlowRateDes = SystemCapacity / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
 
-                    state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
+                    ReportCoilSelection::setCoilLvgWaterTemp(
                         state,
-                        varSpeedCoil.Name,
-                        varSpeedCoil.VarSpeedCoilType,
+                        vsCoil.Name,
+                        vsCoil.coilType,
                         state.dataSize->PlantSizData(PltSizNum).ExitTemp -
                             state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
                 }
 
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(
+                ReportCoilSelection::setCoilEntWaterTemp(
                     state,
-                    varSpeedCoil.Name,
-                    varSpeedCoil.VarSpeedCoilType,
+                    vsCoil.Name,
+                    vsCoil.coilType,
                     state.dataSize->PlantSizData(PltSizNum).ExitTemp); // TRACE 3D Plus coil selection report
 
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(
+                ReportCoilSelection::setCoilWaterDeltaT(
                     state,
-                    varSpeedCoil.Name,
-                    varSpeedCoil.VarSpeedCoilType,
+                    vsCoil.Name,
+                    vsCoil.coilType,
                     state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
             } else {
                 ShowSevereError(state, "Autosizing of water flow requires a loop Sizing:Plant object");
                 ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
-                ShowContinueError(state, format("Occurs in COIL:{}{}  Object = {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix, varSpeedCoil.Name));
+                ShowContinueError(state, format("Occurs in COIL:{}{}  Object = {}", vsCoil.CoolHeatType, CurrentObjSubfix, vsCoil.Name));
                 ErrorsFound = true;
             }
 
             // WRITE THE WATER SIZING OUTPUT
             // FORCE BACK TO THE RATED WATER FLOW RATE WITH THE SAME RATIO DEFINED BY THE CATLOG DATA
             if (RatedCapCoolTotalAutoSized) {
-                RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
+                RatedWaterVolFlowRateDes = vsCoil.RatedCapCoolTotal * vsCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
             } else if (RatedCapHeatAutoSized) {
-                RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
-            }
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(state,
-                                                                                         varSpeedCoil.Name,
-                                                                                         varSpeedCoil.VarSpeedCoilType,
-                                                                                         RatedWaterVolFlowRateDes,
-                                                                                         RatedWaterFlowAutoSized,
-                                                                                         varSpeedCoil.WaterInletNodeNum,
-                                                                                         varSpeedCoil.WaterOutletNodeNum,
-                                                                                         varSpeedCoil.plantLoc.loopNum);
-            varSpeedCoil.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
+                RatedWaterVolFlowRateDes = vsCoil.RatedCapHeat * vsCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
+            }
+            ReportCoilSelection::setCoilWaterFlowNodeNums(state,
+                                                 vsCoil.Name,
+                                                 vsCoil.coilType,
+                                                 RatedWaterVolFlowRateDes,
+                                                 RatedWaterFlowAutoSized,
+                                                 vsCoil.WaterInletNodeNum,
+                                                 vsCoil.WaterOutletNodeNum,
+                                                 vsCoil.plantLoc.loopNum);
+            vsCoil.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
             BaseSizer::reportSizerOutput(state,
-                                         format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                         varSpeedCoil.Name,
+                                         format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                         vsCoil.Name,
                                          "Design Size Rated Water Flow Rate [m3/s]",
                                          RatedWaterVolFlowRateDes);
             // Ensure water flow rate at lower speed must be lower or
             // equal to the flow rate at higher speed. Otherwise, a severe error is isssued.
-            for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
-                if (varSpeedCoil.MSRatedWaterVolFlowRate(Mode) > varSpeedCoil.MSRatedWaterVolFlowRate(Mode + 1) * 1.05) {
+            for (Mode = 1; Mode <= vsCoil.NumOfSpeeds - 1; ++Mode) {
+                if (vsCoil.MSRatedWaterVolFlowRate(Mode) > vsCoil.MSRatedWaterVolFlowRate(Mode + 1) * 1.05) {
                     ShowWarningError(
                         state,
                         format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
-                               varSpeedCoil.VarSpeedCoilType,
-                               varSpeedCoil.Name,
+                               HVAC::coilTypeNames[(int)vsCoil.coilType],
+                               vsCoil.Name,
                                Mode,
                                Mode + 1));
                     ShowContinueError(
                         state,
-                        format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedAirVolFlowRate(Mode), varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)));
+                        format("Instead, {:.2R} > {:.2R}", vsCoil.MSRatedAirVolFlowRate(Mode), vsCoil.MSRatedAirVolFlowRate(Mode + 1)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
                 }
             }
         } else {
-            if (varSpeedCoil.RatedWaterVolFlowRate > 0.0 && RatedWaterVolFlowRateDes > 0.0) {
-                RatedWaterVolFlowRateUser = varSpeedCoil.RatedWaterVolFlowRate;
+            if (vsCoil.RatedWaterVolFlowRate > 0.0 && RatedWaterVolFlowRateDes > 0.0) {
+                RatedWaterVolFlowRateUser = vsCoil.RatedWaterVolFlowRate;
                 BaseSizer::reportSizerOutput(state,
-                                             format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                             varSpeedCoil.Name,
+                                             format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                             vsCoil.Name,
                                              "Design Size Rated Water Flow Rate [m3/s]",
                                              RatedWaterVolFlowRateDes,
                                              "User-Specified Rated Water Flow Rate [m3/s]",
@@ -5308,8 +5175,8 @@ namespace VariableSpeedCoils {
                         state.dataSize->AutoVsHardSizingThreshold) {
                         ShowMessage(
                             state,
-                            format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix));
-                        ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
+                            format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", vsCoil.CoolHeatType, CurrentObjSubfix));
+                        ShowContinueError(state, format("Coil Name = {}", vsCoil.Name));
                         ShowContinueError(state, format("User-Specified Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateUser));
                         ShowContinueError(state, format("differs from Design Size Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateDes));
                         ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
@@ -5320,154 +5187,154 @@ namespace VariableSpeedCoils {
         }
 
         // Save component design water volumetric flow rate.
-        if (varSpeedCoil.RatedWaterVolFlowRate > 0.0 && varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
-            PlantUtilities::RegisterPlantCompDesignFlow(state, varSpeedCoil.WaterInletNodeNum, varSpeedCoil.RatedWaterVolFlowRate);
+        if (vsCoil.RatedWaterVolFlowRate > 0.0 && vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
+            PlantUtilities::RegisterPlantCompDesignFlow(state, vsCoil.WaterInletNodeNum, vsCoil.RatedWaterVolFlowRate);
         }
         // Use 1/2 flow since both cooling and heating coil will save flow yet only 1 will operate at a time
-        else if (varSpeedCoil.RatedWaterVolFlowRate > 0.0) {
-            PlantUtilities::RegisterPlantCompDesignFlow(state, varSpeedCoil.WaterInletNodeNum, 0.5 * varSpeedCoil.RatedWaterVolFlowRate);
+        else if (vsCoil.RatedWaterVolFlowRate > 0.0) {
+            PlantUtilities::RegisterPlantCompDesignFlow(state, vsCoil.WaterInletNodeNum, 0.5 * vsCoil.RatedWaterVolFlowRate);
         }
 
-        RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-            varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+        RatedSourceTempCool = GetCoilRatedSourceTemp(state, DXCoilNum);
+        if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+            vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
 
             if (PltSizNum > 0) {
                 rhoW = rho;
             } else {
-                rhoW = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).glycol->getDensity(state, RatedSourceTempCool, RoutineName);
+                rhoW = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum).glycol->getDensity(state, RatedSourceTempCool, RoutineName);
             }
 
-            varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
-            for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
-                varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
-                varSpeedCoil.MSRatedWaterMassFlowRate(Mode) = varSpeedCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
+            vsCoil.RatedWaterMassFlowRate = vsCoil.RatedWaterVolFlowRate * rhoW;
+            for (Mode = vsCoil.NumOfSpeeds; Mode >= 1; --Mode) {
+                vsCoil.MSRatedWaterVolFlowRate(Mode) = vsCoil.MSRatedTotCap(Mode) * vsCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
+                vsCoil.MSRatedWaterMassFlowRate(Mode) = vsCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
             }
-        } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
+        } else if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
             rhoW = Psychrometrics::RhoH2O(RatedSourceTempCool);
-            varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
-            for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
-                varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
-                varSpeedCoil.MSWHPumpPower(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSWHPumpPowerPerRatedTotCap(Mode);
-                varSpeedCoil.MSRatedWaterMassFlowRate(Mode) = varSpeedCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
+            vsCoil.RatedWaterMassFlowRate = vsCoil.RatedWaterVolFlowRate * rhoW;
+            for (Mode = vsCoil.NumOfSpeeds; Mode >= 1; --Mode) {
+                vsCoil.MSRatedWaterVolFlowRate(Mode) = vsCoil.MSRatedTotCap(Mode) * vsCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
+                vsCoil.MSWHPumpPower(Mode) = vsCoil.MSRatedTotCap(Mode) * vsCoil.MSWHPumpPowerPerRatedTotCap(Mode);
+                vsCoil.MSRatedWaterMassFlowRate(Mode) = vsCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
             }
         }
 
         // Ensure air flow rate at lower speed must be lower or
         // equal to the flow rate at higher speed. Otherwise, a severe error is issued.
-        for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
-            if (varSpeedCoil.MSRatedAirVolFlowRate(Mode) > varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)) {
+        for (Mode = 1; Mode <= vsCoil.NumOfSpeeds - 1; ++Mode) {
+            if (vsCoil.MSRatedAirVolFlowRate(Mode) > vsCoil.MSRatedAirVolFlowRate(Mode + 1)) {
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
-                                        varSpeedCoil.VarSpeedCoilType,
-                                        varSpeedCoil.Name,
+                                        HVAC::coilTypeNames[(int)vsCoil.coilType],
+                                        vsCoil.Name,
                                         Mode,
                                         Mode + 1));
                 ShowContinueError(
                     state,
-                    format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedAirVolFlowRate(Mode), varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)));
+                    format("Instead, {:.2R} > {:.2R}", vsCoil.MSRatedAirVolFlowRate(Mode), vsCoil.MSRatedAirVolFlowRate(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
 
         // Ensure capacity at lower speed must be lower or equal to the capacity at higher speed.
-        for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
-            if (varSpeedCoil.MSRatedTotCap(Mode) > varSpeedCoil.MSRatedTotCap(Mode + 1)) {
+        for (Mode = 1; Mode <= vsCoil.NumOfSpeeds - 1; ++Mode) {
+            if (vsCoil.MSRatedTotCap(Mode) > vsCoil.MSRatedTotCap(Mode + 1)) {
                 ShowWarningError(state,
                                  format("SizeDXCoil: {} {}, Speed {} Rated Total Cooling Capacity must be less than or equal to Speed {} Rated Total "
                                         "Cooling Capacity.",
-                                        varSpeedCoil.VarSpeedCoilType,
-                                        varSpeedCoil.Name,
+                                        HVAC::coilTypeNames[(int)vsCoil.coilType],
+                                        vsCoil.Name,
                                         Mode,
                                         Mode + 1));
-                ShowContinueError(state, format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedTotCap(Mode), varSpeedCoil.MSRatedTotCap(Mode + 1)));
+                ShowContinueError(state, format("Instead, {:.2R} > {:.2R}", vsCoil.MSRatedTotCap(Mode), vsCoil.MSRatedTotCap(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
 
         // convert SHR to rated Bypass factor and effective air side surface area
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-            varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
-                varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
-                                                                 varSpeedCoil.VarSpeedCoilType,
-                                                                 varSpeedCoil.Name,
+        if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+            vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            for (Mode = 1; Mode <= vsCoil.NumOfSpeeds; ++Mode) {
+                vsCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
+                                                           vsCoil.coilType,
+                                                                 vsCoil.Name,
                                                                  RatedInletAirTemp,
                                                                  RatedInletAirHumRat,
-                                                                 varSpeedCoil.MSRatedTotCap(Mode),
-                                                                 varSpeedCoil.MSRatedAirVolFlowRate(Mode),
-                                                                 varSpeedCoil.MSRatedSHR(Mode),
+                                                                 vsCoil.MSRatedTotCap(Mode),
+                                                                 vsCoil.MSRatedAirVolFlowRate(Mode),
+                                                                 vsCoil.MSRatedSHR(Mode),
                                                                  true);
-                if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
-                    varSpeedCoil.MSEffectiveAo(Mode) = -std::log(varSpeedCoil.MSRatedCBF(Mode)) * varSpeedCoil.MSRatedAirMassFlowRate(Mode);
+                if (vsCoil.MSRatedCBF(Mode) > 0.0) {
+                    vsCoil.MSEffectiveAo(Mode) = -std::log(vsCoil.MSRatedCBF(Mode)) * vsCoil.MSRatedAirMassFlowRate(Mode);
                 } else {
-                    varSpeedCoil.MSEffectiveAo(Mode) = 0.0;
+                    vsCoil.MSEffectiveAo(Mode) = 0.0;
                 }
             }
-        } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
-            state.dataHVACGlobal->HPWHInletDBTemp = varSpeedCoil.WHRatedInletDBTemp;
-            state.dataHVACGlobal->HPWHInletWBTemp = varSpeedCoil.WHRatedInletWBTemp;
+        } else if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
+            state.dataHVACGlobal->HPWHInletDBTemp = vsCoil.WHRatedInletDBTemp;
+            state.dataHVACGlobal->HPWHInletWBTemp = vsCoil.WHRatedInletWBTemp;
 
-            for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
-                varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
+            for (Mode = 1; Mode <= vsCoil.NumOfSpeeds; ++Mode) {
+                vsCoil.MSRatedAirMassFlowRate(Mode) = vsCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
             }
 
-            for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
+            for (Mode = 1; Mode <= vsCoil.NumOfSpeeds; ++Mode) {
                 // get cooling capacity, without fan power, i.e. total coil cooling
-                if (varSpeedCoil.CondPumpPowerInCOP)
-                    HPWHCoolCapacity = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) +
-                                       varSpeedCoil.MSWHPumpPower(Mode) - varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
+                if (vsCoil.CondPumpPowerInCOP)
+                    HPWHCoolCapacity = vsCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / vsCoil.MSRatedCOP(Mode)) +
+                                       vsCoil.MSWHPumpPower(Mode) - vsCoil.MSWHPumpPower(Mode) * vsCoil.HPWHCondPumpFracToWater;
                 else
-                    HPWHCoolCapacity = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
-                                       varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
+                    HPWHCoolCapacity = vsCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / vsCoil.MSRatedCOP(Mode)) -
+                                       vsCoil.MSWHPumpPower(Mode) * vsCoil.HPWHCondPumpFracToWater;
 
-                varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
-                                                                 varSpeedCoil.VarSpeedCoilType,
-                                                                 varSpeedCoil.Name,
+                vsCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
+                                                           vsCoil.coilType,
+                                                                 vsCoil.Name,
                                                                  state.dataHVACGlobal->HPWHInletDBTemp,
                                                                  HPInletAirHumRat,
                                                                  HPWHCoolCapacity,
-                                                                 varSpeedCoil.MSRatedAirVolFlowRate(Mode),
-                                                                 varSpeedCoil.MSRatedSHR(Mode),
+                                                                 vsCoil.MSRatedAirVolFlowRate(Mode),
+                                                                 vsCoil.MSRatedSHR(Mode),
                                                                  true);
-                if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
-                    varSpeedCoil.MSEffectiveAo(Mode) = -std::log(varSpeedCoil.MSRatedCBF(Mode)) * varSpeedCoil.MSRatedAirMassFlowRate(Mode);
+                if (vsCoil.MSRatedCBF(Mode) > 0.0) {
+                    vsCoil.MSEffectiveAo(Mode) = -std::log(vsCoil.MSRatedCBF(Mode)) * vsCoil.MSRatedAirMassFlowRate(Mode);
                 } else {
-                    varSpeedCoil.MSEffectiveAo(Mode) = 0.0;
+                    vsCoil.MSEffectiveAo(Mode) = 0.0;
                 }
             }
 
             // update VarSpeedCoil(DXCoilNum).RatedCapCoolTotal
-            Mode = varSpeedCoil.NormSpedLevel;
-            if (varSpeedCoil.CondPumpPowerInCOP) {
-                varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) +
-                                                 varSpeedCoil.MSWHPumpPower(Mode) -
-                                                 varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
+            Mode = vsCoil.NormSpedLevel;
+            if (vsCoil.CondPumpPowerInCOP) {
+                vsCoil.RatedCapCoolTotal = vsCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / vsCoil.MSRatedCOP(Mode)) +
+                                                 vsCoil.MSWHPumpPower(Mode) -
+                                                 vsCoil.MSWHPumpPower(Mode) * vsCoil.HPWHCondPumpFracToWater;
             } else {
-                varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
-                                                 varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
+                vsCoil.RatedCapCoolTotal = vsCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / vsCoil.MSRatedCOP(Mode)) -
+                                                 vsCoil.MSWHPumpPower(Mode) * vsCoil.HPWHCondPumpFracToWater;
             }
         }
 
         // size rated sensible cooling capacity
         RatedCapCoolSensAutoSized = true; // always do that
 
-        if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-                                                                          varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
+        if (vsCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow && (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+                                                                    vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed)) {
             RatedAirMassFlowRate =
-                varSpeedCoil.RatedAirVolFlowRate *
+                vsCoil.RatedAirVolFlowRate *
                 Psychrometrics::PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
             RatedInletEnth = Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, RatedInletAirHumRat);
-            CBFRated = DXCoils::AdjustCBF(varSpeedCoil.MSRatedCBF(NormSpeed), varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed), RatedAirMassFlowRate);
+            CBFRated = DXCoils::AdjustCBF(vsCoil.MSRatedCBF(NormSpeed), vsCoil.MSRatedAirMassFlowRate(NormSpeed), RatedAirMassFlowRate);
             if (CBFRated > 0.999) CBFRated = 0.999;
-            if (varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed) > 1.0e-10) {
-                AirMassFlowRatio = RatedAirMassFlowRate / varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed);
+            if (vsCoil.MSRatedAirMassFlowRate(NormSpeed) > 1.0e-10) {
+                AirMassFlowRatio = RatedAirMassFlowRate / vsCoil.MSRatedAirMassFlowRate(NormSpeed);
             } else {
                 AirMassFlowRatio = 1.0;
             }
 
-            if (varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) > 1.0e-10) {
-                WaterMassFlowRatio = varSpeedCoil.RatedWaterVolFlowRate / varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed);
+            if (vsCoil.MSRatedWaterVolFlowRate(NormSpeed) > 1.0e-10) {
+                WaterMassFlowRatio = vsCoil.RatedWaterVolFlowRate / vsCoil.MSRatedWaterVolFlowRate(NormSpeed);
             } else {
                 WaterMassFlowRatio = 1.0;
             }
@@ -5482,10 +5349,10 @@ namespace VariableSpeedCoils {
                                  WaterMassFlowRatio,
                                  RatedAirMassFlowRate,
                                  CBFRated,
-                                 varSpeedCoil.MSRatedTotCap(NormSpeed),
-                                 varSpeedCoil.MSCCapFTemp(NormSpeed),
-                                 varSpeedCoil.MSCCapAirFFlow(NormSpeed),
-                                 varSpeedCoil.MSCCapWaterFFlow(NormSpeed),
+                                 vsCoil.MSRatedTotCap(NormSpeed),
+                                 vsCoil.MSCCapFTemp(NormSpeed),
+                                 vsCoil.MSCCapAirFFlow(NormSpeed),
+                                 vsCoil.MSCCapWaterFFlow(NormSpeed),
                                  0.0,
                                  0,
                                  0,
@@ -5498,13 +5365,13 @@ namespace VariableSpeedCoils {
                                  state.dataEnvrn->StdBaroPress,
                                  0.0,
                                  1,
-                                 varSpeedCoil.capModFacTotal);
+                                 vsCoil.capModFacTotal);
 
-            RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
-        } else if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow &&
-                   varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
-            SHR = varSpeedCoil.MSRatedSHR(NormSpeed);
-            RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
+            RatedCapCoolSensDes = vsCoil.RatedCapCoolTotal * SHR;
+        } else if (vsCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow &&
+                   vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
+            SHR = vsCoil.MSRatedSHR(NormSpeed);
+            RatedCapCoolSensDes = vsCoil.RatedCapCoolTotal * SHR;
         } else {
             RatedCapCoolSensDes = 0.0;
         }
@@ -5513,45 +5380,45 @@ namespace VariableSpeedCoils {
             RatedCapCoolSensDes = 0.0;
         }
 
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-            varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // always report for cooling mode
+        if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+            vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) { // always report for cooling mode
             if (RatedCapCoolTotalAutoSized) {
-                varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
+                vsCoil.RatedCapCoolSens = RatedCapCoolSensDes;
                 BaseSizer::reportSizerOutput(state,
-                                             format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                             varSpeedCoil.Name,
+                                             format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                             vsCoil.Name,
                                              "Design Size Rated Sensible Cooling Capacity [W]",
-                                             varSpeedCoil.RatedCapCoolSens);
+                                             vsCoil.RatedCapCoolSens);
 
             } else {
                 // sensible capacity does not have an input field
                 if (RatedCapCoolSensDes > 0.0) {
-                    varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
+                    vsCoil.RatedCapCoolSens = RatedCapCoolSensDes;
                     BaseSizer::reportSizerOutput(state,
-                                                 format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
-                                                 varSpeedCoil.Name,
+                                                 format("COIL:{}{}", vsCoil.CoolHeatType, CurrentObjSubfix),
+                                                 vsCoil.Name,
                                                  "Design Size Rated Sensible Cooling Capacity [W]",
                                                  RatedCapCoolSensDes); //, &
                 }
             }
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
+                state, state.dataOutRptPredefined->pdchCoolCoilTotCap, vsCoil.Name, vsCoil.RatedCapCoolTotal);
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchCoolCoilSensCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolSens);
+                state, state.dataOutRptPredefined->pdchCoolCoilSensCap, vsCoil.Name, vsCoil.RatedCapCoolSens);
             OutputReportPredefined::PreDefTableEntry(state,
                                                      state.dataOutRptPredefined->pdchCoolCoilLatCap,
-                                                     varSpeedCoil.Name,
-                                                     varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
-            if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
+                                                     vsCoil.Name,
+                                                     vsCoil.RatedCapCoolTotal - vsCoil.RatedCapCoolSens);
+            if (vsCoil.RatedCapCoolTotal != 0.0) {
                 OutputReportPredefined::PreDefTableEntry(state,
                                                          state.dataOutRptPredefined->pdchCoolCoilSHR,
-                                                         varSpeedCoil.Name,
-                                                         varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
+                                                         vsCoil.Name,
+                                                         vsCoil.RatedCapCoolSens / vsCoil.RatedCapCoolTotal);
             } else {
-                OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, varSpeedCoil.Name, 0.0);
+                OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, vsCoil.Name, 0.0);
             }
             OutputReportPredefined::PreDefTableEntry(
-                state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel));
+                state, state.dataOutRptPredefined->pdchCoolCoilNomEff, vsCoil.Name, vsCoil.MSRatedCOP(vsCoil.NormSpedLevel));
             OutputReportPredefined::addFootNoteSubTable(
                 state,
                 state.dataOutRptPredefined->pdstCoolCoil,
@@ -5560,25 +5427,25 @@ namespace VariableSpeedCoils {
 
         // START SIZING EVAP PRECOOLING PUMP POWER
         IsAutoSize = false;
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            if (varSpeedCoil.EvapCondPumpElecNomPower == DataSizing::AutoSize) {
+        if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            if (vsCoil.EvapCondPumpElecNomPower == DataSizing::AutoSize) {
                 IsAutoSize = true;
             }
             //     Auto size high speed evap condenser pump power to Total Capacity * 0.004266 w/w (15 w/ton)
-            EvapCondPumpElecNomPowerDes = varSpeedCoil.RatedCapCoolTotal * 0.004266;
+            EvapCondPumpElecNomPowerDes = vsCoil.RatedCapCoolTotal * 0.004266;
             if (IsAutoSize) {
-                varSpeedCoil.EvapCondPumpElecNomPower = EvapCondPumpElecNomPowerDes;
+                vsCoil.EvapCondPumpElecNomPower = EvapCondPumpElecNomPowerDes;
                 BaseSizer::reportSizerOutput(state,
                                              "AS VS COOLING COIL",
-                                             varSpeedCoil.Name,
+                                             vsCoil.Name,
                                              "Design Size Evaporative Condenser Pump Rated Power Consumption [W]",
                                              EvapCondPumpElecNomPowerDes);
             } else {
-                if (varSpeedCoil.EvapCondPumpElecNomPower > 0.0 && EvapCondPumpElecNomPowerDes > 0.0) {
-                    EvapCondPumpElecNomPowerUser = varSpeedCoil.EvapCondPumpElecNomPower;
+                if (vsCoil.EvapCondPumpElecNomPower > 0.0 && EvapCondPumpElecNomPowerDes > 0.0) {
+                    EvapCondPumpElecNomPowerUser = vsCoil.EvapCondPumpElecNomPower;
                     BaseSizer::reportSizerOutput(state,
                                                  "AS VS COOLING COIL",
-                                                 varSpeedCoil.Name,
+                                                 vsCoil.Name,
                                                  "Design Size Evaporative Condenser Pump Rated Power Consumption [W]",
                                                  EvapCondPumpElecNomPowerDes,
                                                  "User-Specified Evaporative Condenser Pump Rated Power Consumption [W]",
@@ -5588,9 +5455,9 @@ namespace VariableSpeedCoils {
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(state,
                                         format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
-                                               varSpeedCoil.CoolHeatType,
+                                               vsCoil.CoolHeatType,
                                                CurrentObjSubfix));
-                            ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
+                            ShowContinueError(state, format("Coil Name = {}", vsCoil.Name));
                             ShowContinueError(state,
                                               format("User-Specified Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
                                                      EvapCondPumpElecNomPowerUser));
@@ -5610,25 +5477,25 @@ namespace VariableSpeedCoils {
 
         // Resistive Defrost Heater Capacity = capacity at the first stage
         IsAutoSize = false;
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-            if (varSpeedCoil.DefrostCapacity == DataSizing::AutoSize) {
+        if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+            if (vsCoil.DefrostCapacity == DataSizing::AutoSize) {
                 IsAutoSize = true;
             }
-            if (varSpeedCoil.DefrostStrategy == Resistive) {
-                DefrostCapacityDes = varSpeedCoil.RatedCapHeat;
+            if (vsCoil.DefrostStrategy == Resistive) {
+                DefrostCapacityDes = vsCoil.RatedCapHeat;
             } else {
                 DefrostCapacityDes = 0.0;
             }
             if (IsAutoSize) {
-                varSpeedCoil.DefrostCapacity = DefrostCapacityDes;
+                vsCoil.DefrostCapacity = DefrostCapacityDes;
                 BaseSizer::reportSizerOutput(
-                    state, "AS VS HEATING COIL", varSpeedCoil.Name, "Design Size Resistive Defrost Heater Capacity [W]", DefrostCapacityDes);
+                    state, "AS VS HEATING COIL", vsCoil.Name, "Design Size Resistive Defrost Heater Capacity [W]", DefrostCapacityDes);
             } else {
-                if (varSpeedCoil.DefrostCapacity > 0.0 && DefrostCapacityDes > 0.0 && !HardSizeNoDesRun) {
-                    DefrostCapacityUser = varSpeedCoil.DefrostCapacity;
+                if (vsCoil.DefrostCapacity > 0.0 && DefrostCapacityDes > 0.0 && !HardSizeNoDesRun) {
+                    DefrostCapacityUser = vsCoil.DefrostCapacity;
                     BaseSizer::reportSizerOutput(state,
                                                  "AS VS HEATING COIL",
-                                                 varSpeedCoil.Name,
+                                                 vsCoil.Name,
                                                  "Design Size Resistive Defrost Heater Capacity [W]",
                                                  DefrostCapacityDes,
                                                  "User-Specified Resistive Defrost Heater Capacity [W]",
@@ -5637,9 +5504,9 @@ namespace VariableSpeedCoils {
                         if ((std::abs(DefrostCapacityDes - DefrostCapacityUser) / DefrostCapacityUser) > state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(state,
                                         format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
-                                               varSpeedCoil.CoolHeatType,
+                                               vsCoil.CoolHeatType,
                                                CurrentObjSubfix));
-                            ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
+                            ShowContinueError(state, format("Coil Name = {}", vsCoil.Name));
                             ShowContinueError(state, format("User-Specified Resistive Defrost Heater Capacity of {:.2R} [W]", DefrostCapacityUser));
                             ShowContinueError(state,
                                               format("differs from Design Size Resistive Defrost Heater Capacity of {:.2R} [W]", DefrostCapacityDes));
@@ -5654,13 +5521,13 @@ namespace VariableSpeedCoils {
 
         // test autosized sensible and total cooling capacity for total > sensible
         if (RatedCapCoolSensAutoSized && RatedCapCoolTotalAutoSized) {
-            if (varSpeedCoil.RatedCapCoolSens > varSpeedCoil.RatedCapCoolTotal) {
+            if (vsCoil.RatedCapCoolSens > vsCoil.RatedCapCoolTotal) {
                 ShowWarningError(state,
-                                 format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
+                                 format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", vsCoil.CoolHeatType, vsCoil.Name));
                 ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
                 ShowContinueError(state, "Each of these capacity inputs have been autosized.");
-                ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolSens));
-                ShowContinueError(state, format("Rated Total Cooling Capacity    = {:.2T} W", varSpeedCoil.RatedCapCoolTotal));
+                ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", vsCoil.RatedCapCoolSens));
+                ShowContinueError(state, format("Rated Total Cooling Capacity    = {:.2T} W", vsCoil.RatedCapCoolTotal));
                 ShowContinueError(state, "See eio file for further details.");
                 ShowContinueError(state, "Check Total and Sensible Cooling Capacity Coefficients to ensure they are accurate.");
                 ShowContinueError(state, "Check Zone and System Sizing objects to verify sizing inputs.");
@@ -5679,13 +5546,13 @@ namespace VariableSpeedCoils {
                 ShowContinueError(state, "... to ensure they meet the expected manufacturers performance specifications.");
             }
         } else if (RatedCapCoolTotalAutoSized) {
-            if (varSpeedCoil.RatedCapCoolSens > varSpeedCoil.RatedCapCoolTotal) {
+            if (vsCoil.RatedCapCoolSens > vsCoil.RatedCapCoolTotal) {
                 ShowWarningError(state,
-                                 format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
+                                 format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", vsCoil.CoolHeatType, vsCoil.Name));
                 ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
                 ShowContinueError(state, "Only the rated total capacity input is autosized, consider autosizing both inputs.");
-                ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolSens));
-                ShowContinueError(state, format("Rated Total Cooling Capacity    = {:.2T} W", varSpeedCoil.RatedCapCoolTotal));
+                ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", vsCoil.RatedCapCoolSens));
+                ShowContinueError(state, format("Rated Total Cooling Capacity    = {:.2T} W", vsCoil.RatedCapCoolTotal));
                 ShowContinueError(state, "See eio file for further details.");
                 ShowContinueError(state, "Check Total and Sensible Cooling Capacity Coefficients to ensure they are accurate.");
                 ShowContinueError(state, "Check Zone and System Sizing objects to verify sizing inputs.");
@@ -5703,10 +5570,10 @@ namespace VariableSpeedCoils {
 
         Array1D<DataHeatBalance::RefrigCondenserType> CondenserType;
         StandardRatings::HPdefrostControl DefrostControl;
-        switch (varSpeedCoil.VSCoilType) {
-        case HVAC::Coil_CoolingAirToAirVariableSpeed:
-            CondenserType.push_back(varSpeedCoil.CondenserType);
-            switch (varSpeedCoil.DefrostControl) // defrost control; 1=timed, 2=on-demand
+        switch (vsCoil.coilType) {
+        case HVAC::CoilType::CoolingDXVariableSpeed:
+            CondenserType.push_back(vsCoil.CondenserType);
+            switch (vsCoil.DefrostControl) // defrost control; 1=timed, 2=on-demand
             {
             case 2:
                 DefrostControl = StandardRatings::HPdefrostControl::OnDemand;
@@ -5716,31 +5583,30 @@ namespace VariableSpeedCoils {
                 DefrostControl = StandardRatings::HPdefrostControl::Timed;
                 break;
             }
-            if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
+            if (vsCoil.RatedCapCoolTotal > 0.0) {
                 StandardRatings::CalcDXCoilStandardRating(state,
-                                                          varSpeedCoil.Name,
-                                                          varSpeedCoil.VarSpeedCoilType,
-                                                          varSpeedCoil.VSCoilType,
-                                                          varSpeedCoil.NumOfSpeeds,
-                                                          varSpeedCoil.MSRatedTotCap,
-                                                          varSpeedCoil.MSRatedCOP,
-                                                          varSpeedCoil.MSCCapAirFFlow,
-                                                          varSpeedCoil.MSCCapFTemp,
-                                                          varSpeedCoil.MSEIRAirFFlow,
-                                                          varSpeedCoil.MSEIRFTemp,
-                                                          varSpeedCoil.PLFFPLR,
-                                                          varSpeedCoil.MSRatedAirVolFlowRate,
-                                                          varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2017,
-                                                          varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2023,
+                                                          vsCoil.Name,
+                                                          vsCoil.coilType,
+                                                          vsCoil.NumOfSpeeds,
+                                                          vsCoil.MSRatedTotCap,
+                                                          vsCoil.MSRatedCOP,
+                                                          vsCoil.MSCCapAirFFlow,
+                                                          vsCoil.MSCCapFTemp,
+                                                          vsCoil.MSEIRAirFFlow,
+                                                          vsCoil.MSEIRFTemp,
+                                                          vsCoil.PLFFPLR,
+                                                          vsCoil.MSRatedAirVolFlowRate,
+                                                          vsCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2017,
+                                                          vsCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2023,
                                                           CondenserType,
-                                                          0, // varSpeedCoil.RegionNum, // ??
-                                                          varSpeedCoil.MinOATCompressor,
-                                                          varSpeedCoil.OATempCompressorOn,
-                                                          false, // varSpeedCoil.OATempCompressorOnOffBlank, // ??
+                                                          0, // vsCoil.RegionNum, // ??
+                                                          vsCoil.MinOATCompressor,
+                                                          vsCoil.OATempCompressorOn,
+                                                          false, // vsCoil.OATempCompressorOnOffBlank, // ??
                                                           DefrostControl,
                                                           ObjexxFCL::Optional_bool_const(),
-                                                          varSpeedCoil.RatedCapCoolTotal,
-                                                          varSpeedCoil.RatedAirVolFlowRate);
+                                                          vsCoil.RatedCapCoolTotal,
+                                                          vsCoil.RatedAirVolFlowRate);
             }
             break;
         default:
@@ -5835,6 +5701,8 @@ namespace VariableSpeedCoils {
         Real64 SpecHumOut;         // outlet air specific humidity
         Real64 rhoair(0);          // entering air density
 
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+        
         if (state.dataVariableSpeedCoils->firstTime) {
             // Set indoor air conditions to the rated condition
             state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init = 26.7;
@@ -5852,7 +5720,7 @@ namespace VariableSpeedCoils {
                                            state.dataEnvrn->OutBaroPress,
                                            RoutineName);
 
-        MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+        MaxSpeed = vsCoil.NumOfSpeeds;
 
         // must be placed inside the loop, otherwise cause bug in release mode, need to be present at two places
         if (SpeedNum > MaxSpeed) {
@@ -5863,26 +5731,25 @@ namespace VariableSpeedCoils {
 
         //  LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
         if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
-                state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
+            vsCoil.AirMassFlowRate = state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).MassFlowRate / PartLoadRatio;
         }
 
-        Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated;
-        Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
+        Twet_Rated = vsCoil.Twet_Rated;
+        Gamma_Rated = vsCoil.Gamma_Rated;
 
-        state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
+        state.dataVariableSpeedCoils->LoadSideMassFlowRate = vsCoil.AirMassFlowRate;
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+        if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
             // Get condenser outdoor node info from DX COOLING Coil
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum != 0) {
+            if (vsCoil.CondenserInletNodeNum != 0) {
                 state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Temp;
                 state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).HumRat;
                 state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Press;
                 state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).OutAirWetBulb;
             } else {
                 state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling = state.dataEnvrn->OutDryBulbTemp;
                 state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling = state.dataEnvrn->OutHumRat;
@@ -5896,20 +5763,20 @@ namespace VariableSpeedCoils {
                                                              state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling);
 
             if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
-                CondAirMassFlow = RhoSourceAir * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal);
+                CondAirMassFlow = RhoSourceAir * vsCoil.EvapCondAirFlow(SpeedCal);
             } else {
                 CondAirMassFlow =
-                    RhoSourceAir * (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal) * SpeedRatio +
-                                    (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal - 1));
+                    RhoSourceAir * (vsCoil.EvapCondAirFlow(SpeedCal) * SpeedRatio +
+                                    (1.0 - SpeedRatio) * vsCoil.EvapCondAirFlow(SpeedCal - 1));
             }
 
             // AIR COOL OR EVAP COOLED CONDENSER
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
+            if (vsCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
                 if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
-                    EvapCondEffectSped = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal);
+                    EvapCondEffectSped = vsCoil.EvapCondEffect(SpeedCal);
                 } else {
-                    EvapCondEffectSped = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal) * SpeedRatio +
-                                         (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal - 1);
+                    EvapCondEffectSped = vsCoil.EvapCondEffect(SpeedCal) * SpeedRatio +
+                                         (1.0 - SpeedRatio) * vsCoil.EvapCondEffect(SpeedCal - 1);
                 }
                 // (Outdoor wet-bulb temp from DataEnvironment) + (1.0-EvapCondEffectiveness) * (drybulb - wetbulb)
                 CondInletTemp = state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling +
@@ -5932,55 +5799,55 @@ namespace VariableSpeedCoils {
             state.dataVariableSpeedCoils->SourceSideInletTemp = CondInletTemp;
             state.dataVariableSpeedCoils->SourceSideInletEnth = Psychrometrics::PsyHFnTdbW(CondInletTemp, CondInletHumRat);
             CpSource = Psychrometrics::PsyCpAirFnW(CondInletHumRat);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondInletTemp = CondInletTemp;
+            vsCoil.CondInletTemp = CondInletTemp;
 
             // If used in a heat pump, the value of MaxOAT in the heating coil overrides that in the cooling coil (in GetInput)
             // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
             if (state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling <
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
+                vsCoil.MaxOATCrankcaseHeater) {
                 state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
+                    vsCoil.CrankcaseHeaterCapacity;
+                if (vsCoil.CrankcaseHeaterCapacityCurveIndex > 0) {
                     state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *=
                         Curve::CurveValue(state,
-                                          state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
+                                          vsCoil.CrankcaseHeaterCapacityCurveIndex,
                                           state.dataEnvrn->OutDryBulbTemp);
                 }
             } else {
                 state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling = 0.0;
             }
         } else {
-            state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
-            state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
-            state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
-            CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
+            state.dataVariableSpeedCoils->SourceSideMassFlowRate = vsCoil.WaterMassFlowRate;
+            state.dataVariableSpeedCoils->SourceSideInletTemp = vsCoil.InletWaterTemp;
+            state.dataVariableSpeedCoils->SourceSideInletEnth = vsCoil.InletWaterEnthalpy;
+            CpSource = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                            .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp);
         }
 
         // Check for flows, do not perform simulation if no flow in load side or source side.
         if (state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0 || state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0) {
 
-            if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
-                (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Air) &&
+            if ((vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) &&
+                (vsCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) &&
                 (state.dataVariableSpeedCoils->LoadSideMassFlowRate > 0.0)) {
                 // ALLOW SIMULATION IF AIR-COOLED CONDENSER COIL
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
+                vsCoil.SimFlag = true;
             } else {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
+                vsCoil.SimFlag = false;
                 return;
             }
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
+            vsCoil.SimFlag = true;
         }
 
-        if (compressorOp == HVAC::CompressorOp::Off || state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
+        if (compressorOp == HVAC::CompressorOp::Off || vsCoil.RatedCapCoolTotal <= 0.0) {
+            vsCoil.SimFlag = false;
             return;
         }
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
-            (CondInletTemp < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor)) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
+        if ((vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) &&
+            (CondInletTemp < vsCoil.MinOATCompressor)) {
+            vsCoil.SimFlag = false;
             return;
         }
 
@@ -5998,17 +5865,17 @@ namespace VariableSpeedCoils {
         }
 
         // Set indoor air conditions to the actual condition
-        LoadSideInletDBTemp_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
-        LoadSideInletHumRat_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
+        LoadSideInletDBTemp_Unit = vsCoil.InletAirDBTemp;
+        LoadSideInletHumRat_Unit = vsCoil.InletAirHumRat;
         LoadSideInletWBTemp_Unit =
             Psychrometrics::PsyTwbFnTdbWPb(state, LoadSideInletDBTemp_Unit, LoadSideInletHumRat_Unit, state.dataEnvrn->OutBaroPress, RoutineName);
-        LoadSideInletEnth_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
+        LoadSideInletEnth_Unit = vsCoil.InletAirEnthalpy;
         CpAir_Unit = Psychrometrics::PsyCpAirFnW(LoadSideInletHumRat_Unit);
 
         state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
+        vsCoil.RunFrac = 1.0;
         if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
-            PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
+            PLF = Curve::CurveValue(state, vsCoil.PLFFPLR, PartLoadRatio);
             if (PLF < 0.7) {
                 PLF = 0.7;
             }
@@ -6016,13 +5883,13 @@ namespace VariableSpeedCoils {
                 state.dataHVACGlobal->OnOffFanPartLoadFraction =
                     PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
             // calculate the run time fraction
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
+            vsCoil.RunFrac = PartLoadRatio / PLF;
+            vsCoil.PartLoadRatio = PartLoadRatio;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
-            } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
+            if (vsCoil.RunFrac > 1.0) {
+                vsCoil.RunFrac = 1.0; // Reset coil runtime fraction to 1.0
+            } else if (vsCoil.RunFrac < 0.0) {
+                vsCoil.RunFrac = 0.0;
             }
         }
 
@@ -6053,17 +5920,17 @@ namespace VariableSpeedCoils {
 
             if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
                 AirMassFlowRatio =
-                    state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
+                    state.dataVariableSpeedCoils->LoadSideMassFlowRate / vsCoil.DesignAirMassFlowRate;
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     WaterMassFlowRatio = 1.0;
                 } else {
                     WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
+                                         vsCoil.DesignWaterMassFlowRate;
                 }
 
-                CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
+                CBFSpeed = DXCoils::AdjustCBF(vsCoil.MSRatedCBF(SpeedCal),
+                                              vsCoil.MSRatedAirMassFlowRate(SpeedCal),
                                               state.dataVariableSpeedCoils->LoadSideMassFlowRate);
 
                 if (CBFSpeed > 0.999) CBFSpeed = 0.999;
@@ -6077,10 +5944,10 @@ namespace VariableSpeedCoils {
                                      WaterMassFlowRatio,
                                      state.dataVariableSpeedCoils->LoadSideMassFlowRate,
                                      CBFSpeed,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
+                                     vsCoil.MSRatedTotCap(SpeedCal),
+                                     vsCoil.MSCCapFTemp(SpeedCal),
+                                     vsCoil.MSCCapAirFFlow(SpeedCal),
+                                     vsCoil.MSCCapWaterFFlow(SpeedCal),
                                      0.0,
                                      0,
                                      0,
@@ -6090,30 +5957,30 @@ namespace VariableSpeedCoils {
                                      state.dataVariableSpeedCoils->QLoadTotal,
                                      SHR,
                                      state.dataVariableSpeedCoils->SourceSideInletTemp,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
+                                     vsCoil.InletAirPressure,
                                      0.0,
                                      1,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
+                                     vsCoil.capModFacTotal);
 
                 EIRTempModFac = Curve::CurveValue(state,
-                                                  state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                                  vsCoil.MSEIRFTemp(SpeedCal),
                                                   state.dataVariableSpeedCoils->LoadSideInletWBTemp,
                                                   state.dataVariableSpeedCoils->SourceSideInletTemp);
                 EIRAirFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     EIRWaterFFModFac = 1.0;
                 } else {
                     EIRWaterFFModFac =
-                        Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                        Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
                 }
 
-                EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
+                EIR = (1.0 / vsCoil.MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
                       EIRWaterFFModFac;
 
-                CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
+                CBFSpeed = DXCoils::AdjustCBF(vsCoil.MSRatedCBF(SpeedCal),
+                                              vsCoil.MSRatedAirMassFlowRate(SpeedCal),
                                               state.dataVariableSpeedCoils->LoadSideMassFlowRate);
 
                 if (CBFSpeed > 0.999) CBFSpeed = 0.999;
@@ -6127,10 +5994,10 @@ namespace VariableSpeedCoils {
                                      WaterMassFlowRatio,
                                      state.dataVariableSpeedCoils->LoadSideMassFlowRate,
                                      CBFSpeed,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
+                                     vsCoil.MSRatedTotCap(SpeedCal),
+                                     vsCoil.MSCCapFTemp(SpeedCal),
+                                     vsCoil.MSCCapAirFFlow(SpeedCal),
+                                     vsCoil.MSCCapWaterFFlow(SpeedCal),
                                      0.0,
                                      0,
                                      0,
@@ -6140,36 +6007,36 @@ namespace VariableSpeedCoils {
                                      state.dataVariableSpeedCoils->QLoadTotal,
                                      SHR,
                                      state.dataVariableSpeedCoils->SourceSideInletTemp,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
+                                     vsCoil.InletAirPressure,
                                      0.0,
                                      1,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
+                                     vsCoil.capModFacTotal);
 
                 state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     QWasteHeat = 0.0;
                 } else {
                     QWasteHeat =
-                        state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
+                        state.dataVariableSpeedCoils->Winput * vsCoil.MSWasteHeatFrac(SpeedCal);
                     QWasteHeat *= Curve::CurveValue(state,
-                                                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
+                                                    vsCoil.MSWasteHeat(SpeedCal),
                                                     state.dataVariableSpeedCoils->LoadSideInletWBTemp,
                                                     state.dataVariableSpeedCoils->SourceSideInletTemp);
                 }
             } else {
                 AirMassFlowRatio =
-                    state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
+                    state.dataVariableSpeedCoils->LoadSideMassFlowRate / vsCoil.DesignAirMassFlowRate;
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     WaterMassFlowRatio = 1.0;
                 } else {
                     WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
-                                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
+                                         vsCoil.DesignWaterMassFlowRate;
                 }
 
-                AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
-                        (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
+                AoEff = vsCoil.MSEffectiveAo(SpeedCal) * SpeedRatio +
+                        (1.0 - SpeedRatio) * vsCoil.MSEffectiveAo(SpeedCal - 1);
 
                 CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
 
@@ -6184,78 +6051,78 @@ namespace VariableSpeedCoils {
                                      WaterMassFlowRatio,
                                      state.dataVariableSpeedCoils->LoadSideMassFlowRate,
                                      CBFSpeed,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal - 1),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal - 1),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal - 1),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
+                                     vsCoil.MSRatedTotCap(SpeedCal - 1),
+                                     vsCoil.MSCCapFTemp(SpeedCal - 1),
+                                     vsCoil.MSCCapAirFFlow(SpeedCal - 1),
+                                     vsCoil.MSCCapWaterFFlow(SpeedCal - 1),
+                                     vsCoil.MSRatedTotCap(SpeedCal),
+                                     vsCoil.MSCCapFTemp(SpeedCal),
+                                     vsCoil.MSCCapAirFFlow(SpeedCal),
+                                     vsCoil.MSCCapWaterFFlow(SpeedCal),
                                      QLoadTotal1,
                                      QLoadTotal2,
                                      state.dataVariableSpeedCoils->QLoadTotal,
                                      SHR,
                                      state.dataVariableSpeedCoils->SourceSideInletTemp,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
+                                     vsCoil.InletAirPressure,
                                      SpeedRatio,
                                      2,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
+                                     vsCoil.capModFacTotal);
 
                 SpeedCal = SpeedNum - 1;
                 EIRTempModFac = Curve::CurveValue(state,
-                                                  state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                                  vsCoil.MSEIRFTemp(SpeedCal),
                                                   state.dataVariableSpeedCoils->LoadSideInletWBTemp,
                                                   state.dataVariableSpeedCoils->SourceSideInletTemp);
                 EIRAirFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     EIRWaterFFModFac = 1.0;
                 } else {
                     EIRWaterFFModFac =
-                        Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                        Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
                 }
 
-                EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
+                EIR = (1.0 / vsCoil.MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
                       EIRWaterFFModFac;
                 Winput1 = QLoadTotal1 * EIR;
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     QWasteHeat1 = 0.0;
                 } else {
-                    QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
+                    QWasteHeat1 = Winput1 * vsCoil.MSWasteHeatFrac(SpeedCal);
                     QWasteHeat1 *= Curve::CurveValue(state,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
+                                                     vsCoil.MSWasteHeat(SpeedCal),
                                                      state.dataVariableSpeedCoils->LoadSideInletWBTemp,
                                                      state.dataVariableSpeedCoils->SourceSideInletTemp);
                 }
 
                 SpeedCal = SpeedNum;
                 EIRTempModFac = Curve::CurveValue(state,
-                                                  state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                                  vsCoil.MSEIRFTemp(SpeedCal),
                                                   state.dataVariableSpeedCoils->LoadSideInletWBTemp,
                                                   state.dataVariableSpeedCoils->SourceSideInletTemp);
                 EIRAirFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     EIRWaterFFModFac = 1.0;
                 } else {
                     EIRWaterFFModFac =
-                        Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                        Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
                 }
 
-                EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
+                EIR = (1.0 / vsCoil.MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
                       EIRWaterFFModFac;
                 Winput2 = QLoadTotal2 * EIR;
 
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+                if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
                     QWasteHeat2 = 0.0;
                 } else {
-                    QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
+                    QWasteHeat2 = Winput2 * vsCoil.MSWasteHeatFrac(SpeedCal);
                     QWasteHeat2 *= Curve::CurveValue(state,
-                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
+                                                     vsCoil.MSWasteHeat(SpeedCal),
                                                      state.dataVariableSpeedCoils->LoadSideInletWBTemp,
                                                      state.dataVariableSpeedCoils->SourceSideInletTemp);
                 }
@@ -6289,7 +6156,7 @@ namespace VariableSpeedCoils {
                                               DXCoilNum,
                                               SHRss,
                                               fanOp,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
+                                              vsCoil.RunFrac,
                                               state.dataVariableSpeedCoils->QLatRated,
                                               state.dataVariableSpeedCoils->QLatActual,
                                               state.dataVariableSpeedCoils->LoadSideInletDBTemp,
@@ -6307,48 +6174,47 @@ namespace VariableSpeedCoils {
     LOOP_exit:;
 
         // considering hot gas reheat here
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HOTGASREHEATFLG > 0) {
+        if (vsCoil.HOTGASREHEATFLG > 0) {
             state.dataVariableSpeedCoils->QLoadTotal -= QWasteHeat;
             state.dataVariableSpeedCoils->QSensible -= QWasteHeat;
             SHReff = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
         }
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
+        vsCoil.BasinHeaterPower = 0.0;
+        vsCoil.CrankcaseHeaterPower = 0.0;
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
+        if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            if (vsCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
                 //******************
                 //             WATER CONSUMPTION IN m3 OF WATER FOR DIRECT
                 //             H2O [m3/s] = Delta W[kgWater/kgDryAir]*Mass Flow Air[kgDryAir/s]
                 //                                /RhoWater [kgWater/m3]
                 //******************
                 RhoEvapCondWater = Psychrometrics::RhoH2O(state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate =
+
+                // Please parenthesize this
+                vsCoil.EvapWaterConsumpRate =
                     (CondInletHumRat - state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling) * CondAirMassFlow / RhoEvapCondWater *
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower *
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
+                    vsCoil.RunFrac;
+                vsCoil.EvapCondPumpElecPower = vsCoil.EvapCondPumpElecNomPower * vsCoil.RunFrac;
                 // Calculate basin heater power
                 CalcBasinHeaterPower(state,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).basinHeaterSched,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp,
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower);
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower *=
-                    (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
+                                     vsCoil.BasinHeaterPowerFTempDiff,
+                                     vsCoil.basinHeaterSched,
+                                     vsCoil.BasinHeaterSetPointTemp,
+                                     vsCoil.BasinHeaterPower);
+                vsCoil.BasinHeaterPower *=
+                    (1.0 - vsCoil.RunFrac);
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
-                state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *
-                (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
+            vsCoil.CrankcaseHeaterPower =
+                state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling * (1.0 - vsCoil.RunFrac);
 
             // set water system demand request (if needed)
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyMode == WaterSupplyFromTank) {
-                state.dataWaterData->WaterStorage(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupTankID)
-                    .VdotRequestDemand(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterTankDemandARRID) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate;
+            if (vsCoil.EvapWaterSupplyMode == WaterSupplyFromTank) {
+                state.dataWaterData->WaterStorage(vsCoil.EvapWaterSupTankID)
+                    .VdotRequestDemand(vsCoil.EvapWaterTankDemandARRID) =
+                    vsCoil.EvapWaterConsumpRate;
             }
         }
 
@@ -6364,7 +6230,7 @@ namespace VariableSpeedCoils {
             MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
                                                       state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
                                                       0.9999,
-                                                      state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
+                                                      vsCoil.InletAirPressure,
                                                       RoutineName);
             MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
             if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
@@ -6381,21 +6247,21 @@ namespace VariableSpeedCoils {
         // Actual outlet conditions are "average" for time step
         if (fanOp == HVAC::FanOp::Continuous) {
             // continuous fan, cycling compressor
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
+            vsCoil.OutletAirEnthalpy =
                 PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
                 (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
+            vsCoil.OutletAirHumRat =
                 PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
                 (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
-                Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
+            vsCoil.OutletAirDBTemp =
+                Psychrometrics::PsyTdbFnHW(vsCoil.OutletAirEnthalpy,
+                                           vsCoil.OutletAirHumRat);
             state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
         } else {
             // default to cycling fan, cycling compressor
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
+            vsCoil.OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
+            vsCoil.OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
+            vsCoil.OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
             state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
         }
 
@@ -6403,37 +6269,33 @@ namespace VariableSpeedCoils {
         state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
         state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
         // count the powr separately
-        state.dataVariableSpeedCoils->Winput *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
+        state.dataVariableSpeedCoils->Winput *= vsCoil.RunFrac;
         state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
         QWasteHeat *= PartLoadRatio;
 
         // Update heat pump data structure
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
-            state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
-            (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower * TimeStepSysSec;
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
+        vsCoil.Power = state.dataVariableSpeedCoils->Winput;
+        vsCoil.QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
+        vsCoil.QSensible = state.dataVariableSpeedCoils->QSensible;
+        vsCoil.QLatent = state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
+        vsCoil.QSource = state.dataVariableSpeedCoils->QSource;
+        vsCoil.Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
+        vsCoil.EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
+        vsCoil.EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
+        vsCoil.EnergyLatent = (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
+        vsCoil.EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
+        vsCoil.CrankcaseHeaterConsumption = vsCoil.CrankcaseHeaterPower * TimeStepSysSec;
+        vsCoil.EvapWaterConsump = vsCoil.EvapWaterConsumpRate * TimeStepSysSec;
+        vsCoil.BasinHeaterConsumption = vsCoil.BasinHeaterPower * TimeStepSysSec;
+        vsCoil.EvapCondPumpElecConsumption = vsCoil.EvapCondPumpElecPower * TimeStepSysSec;
+        if (vsCoil.RunFrac == 0.0) {
+            vsCoil.COP = 0.0;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
-                state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
+            vsCoil.COP = state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
         }
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
+        
+        vsCoil.PartLoadRatio = PartLoadRatio;
+        vsCoil.AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
         rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
                                                    state.dataEnvrn->OutBaroPress,
                                                    state.dataVariableSpeedCoils->LoadSideInletDBTemp,
@@ -6442,22 +6304,21 @@ namespace VariableSpeedCoils {
         // This seems wrong, initializing mass flow rate to StdRhoAir or actual air density,
         // then using that mass flow rate, then back calculating volume using inlet conditions.
         // Volume should be constant through a fan and air mass flow rate should vary based on inlet conditions.
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
+        vsCoil.AirVolFlowRate = vsCoil.AirMassFlowRate / rhoair;
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
+        if (vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
+            vsCoil.WaterMassFlowRate = 0.0;
+            vsCoil.OutletWaterTemp = 0.0;
+            vsCoil.OutletWaterEnthalpy = 0.0;
             state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
             if (state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal > 0.0)
                 state.dataVariableSpeedCoils->QSource -= state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
+            vsCoil.WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
+            vsCoil.OutletWaterTemp =
                 state.dataVariableSpeedCoils->SourceSideInletTemp +
                 state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
+            vsCoil.OutletWaterEnthalpy =
                 state.dataVariableSpeedCoils->SourceSideInletEnth +
                 state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
             state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
@@ -6467,22 +6328,22 @@ namespace VariableSpeedCoils {
         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
+        vsCoil.QWasteHeat = QWasteHeat;
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode == CondensateToTank) {
+        if (vsCoil.CondensateCollectMode == CondensateToTank) {
             // calculate and report condensation rates  (how much water extracted from the air stream)
             // water flow of water in m3/s for water system interactions
-            RhoWater = Psychrometrics::RhoH2O((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp +
-                                               state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp) /
+            RhoWater = Psychrometrics::RhoH2O((vsCoil.InletAirDBTemp +
+                                               vsCoil.OutletAirDBTemp) /
                                               2.0);
             //     CR9155 Remove specific humidity calculations
             SpecHumIn = state.dataVariableSpeedCoils->LoadSideInletHumRat;
             SpecHumOut = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
             //  mdot * del HumRat / rho water
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot =
+            vsCoil.CondensateVdot =
                 max(0.0, (state.dataVariableSpeedCoils->LoadSideMassFlowRate * (SpecHumIn - SpecHumOut) / RhoWater));
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot * TimeStepSysSec;
+            vsCoil.CondensateVol =
+                vsCoil.CondensateVdot * TimeStepSysSec;
         }
     }
 
@@ -6564,15 +6425,17 @@ namespace VariableSpeedCoils {
         Real64 RhoWater = 0.0;        // water density
 
         // note: load side is the evaporator side, and source side is the condenser side
-
-        int CondInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
-        int CondOutletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum;
+        auto const &s_node = state.dataLoopNodes;
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+        
+        int CondInletNode = vsCoil.WaterInletNodeNum;
+        int CondOutletNode = vsCoil.WaterOutletNodeNum;
         // If heat pump water heater is OFF, set outlet to inlet and RETURN
         if (PartLoadRatio == 0.0) {
             state.dataLoopNodes->Node(CondOutletNode) = state.dataLoopNodes->Node(CondInletNode);
             return;
         } else {
-            EvapInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
+            EvapInletNode = vsCoil.AirInletNodeNum;
             InletWaterTemp = state.dataLoopNodes->Node(CondInletNode).Temp;
             CondInletMassFlowRate = state.dataLoopNodes->Node(CondInletNode).MassFlowRate;
             EvapInletMassFlowRate = state.dataLoopNodes->Node(EvapInletNode).MassFlowRate;
@@ -6588,11 +6451,11 @@ namespace VariableSpeedCoils {
             EvapInletMassFlowRate = EvapInletMassFlowRate / PartLoadRatio;
         }
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = EvapInletMassFlowRate;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = CondInletMassFlowRate;
+        vsCoil.AirMassFlowRate = EvapInletMassFlowRate;
+        vsCoil.WaterMassFlowRate = CondInletMassFlowRate;
 
         // determine inlet air temperature type for curve objects
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
+        if (vsCoil.InletAirTemperatureType == HVAC::OATType::WetBulb) {
             InletAirTemp = state.dataHVACGlobal->HPWHInletWBTemp;
         } else {
             InletAirTemp = state.dataHVACGlobal->HPWHInletDBTemp;
@@ -6617,12 +6480,12 @@ namespace VariableSpeedCoils {
             state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataEnvrn->OutEnthalpy;
 
             // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
-            if (state.dataEnvrn->OutDryBulbTemp < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
-                CrankcaseHeatingPower = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
+            if (state.dataEnvrn->OutDryBulbTemp < vsCoil.MaxOATCrankcaseHeater) {
+                CrankcaseHeatingPower = vsCoil.CrankcaseHeaterCapacity;
+                if (vsCoil.CrankcaseHeaterCapacityCurveIndex > 0) {
                     CrankcaseHeatingPower *=
                         Curve::CurveValue(state,
-                                          state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
+                                          vsCoil.CrankcaseHeaterCapacityCurveIndex,
                                           state.dataEnvrn->OutDryBulbTemp);
                 }
             };
@@ -6632,21 +6495,21 @@ namespace VariableSpeedCoils {
         state.dataVariableSpeedCoils->SourceSideMassFlowRate = CondInletMassFlowRate;
         state.dataVariableSpeedCoils->SourceSideInletTemp = InletWaterTemp;
         state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataLoopNodes->Node(CondInletNode).Enthalpy;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataVariableSpeedCoils->SourceSideInletEnth;
+        vsCoil.InletWaterEnthalpy = state.dataVariableSpeedCoils->SourceSideInletEnth;
 
         // Check for flows, do not perform simulation if no flow in load side or source side.
         if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
+            vsCoil.SimFlag = false;
             return;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
+            vsCoil.SimFlag = true;
         }
 
         // part-load calculation
         state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
+        vsCoil.RunFrac = 1.0;
         if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
-            PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
+            PLF = Curve::CurveValue(state, vsCoil.PLFFPLR, PartLoadRatio);
             if (PLF < 0.7) {
                 PLF = 0.7;
             }
@@ -6654,17 +6517,17 @@ namespace VariableSpeedCoils {
                 state.dataHVACGlobal->OnOffFanPartLoadFraction =
                     PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
             // calculate the run time fraction
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
+            vsCoil.RunFrac = PartLoadRatio / PLF;
+            vsCoil.PartLoadRatio = PartLoadRatio;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
-            } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
+            if (vsCoil.RunFrac > 1.0) {
+                vsCoil.RunFrac = 1.0; // Reset coil runtime fraction to 1.0
+            } else if (vsCoil.RunFrac < 0.0) {
+                vsCoil.RunFrac = 0.0;
             }
         }
 
-        int MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+        int MaxSpeed = vsCoil.NumOfSpeeds;
 
         // interpolate between speeds
         // must be placed inside the loop, otherwise cause bug in release mode
@@ -6675,134 +6538,134 @@ namespace VariableSpeedCoils {
         }
 
         Real64 locFanElecPower = 0.0; // local for fan electric power
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
-            locFanElecPower = state.dataFans->fans(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex)->totalPower;
+        if (vsCoil.SupplyFanIndex > 0) {
+            locFanElecPower = state.dataFans->fans(vsCoil.SupplyFanIndex)->totalPower;
         }
         if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
             AirMassFlowRatio =
-                state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
+                state.dataVariableSpeedCoils->LoadSideMassFlowRate / vsCoil.DesignAirMassFlowRate;
             WaterMassFlowRatio =
-                state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
+                state.dataVariableSpeedCoils->SourceSideMassFlowRate / vsCoil.DesignWaterMassFlowRate;
+            vsCoil.HPWHCondPumpElecNomPower =
+                vsCoil.MSWHPumpPower(SpeedCal);
 
             COPTempModFac = Curve::CurveValue(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                              vsCoil.MSEIRFTemp(SpeedCal),
                                               InletAirTemp,
                                               state.dataVariableSpeedCoils->SourceSideInletTemp);
             COPAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
             COPWaterFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
 
-            COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
+            COP = vsCoil.MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
 
             TOTCAPTempModFac = Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
+                                                 vsCoil.MSCCapFTemp(SpeedCal),
                                                  InletAirTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             //   Get capacity modifying factor (function of mass flow) for off-rated conditions
             TOTCAPAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
             // Get capacity modifying factor (function of mass flow) for off-rated conditions
             TOTCAPWaterFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
 
-            OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
+            OperatingHeatingCapacity = vsCoil.MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
                                        TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
 
             state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
             OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
 
             OperatingHeatingCOP = COP;
-            PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
-                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
+            PumpHeatToWater = vsCoil.HPWHCondPumpElecNomPower *
+                              vsCoil.HPWHCondPumpFracToWater;
             TankHeatingCOP = OperatingHeatingCOP;
 
             // account for pump heat if not included in total water heating capacity
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
+            if (vsCoil.CondPumpHeatInCapacity) {
                 TotalTankHeatingCapacity = OperatingHeatingCapacity;
             } else {
                 TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
             }
 
             // calculate evaporator total cooling capacity
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
+            if (vsCoil.FanPowerIncludedInCOP) {
+                if (vsCoil.CondPumpPowerInCOP) {
                     //       make sure fan power is full load fan power, it isn't though,
-                    CompressorPower = OperatingHeatingPower - locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac -
-                                      state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
+                    CompressorPower = OperatingHeatingPower - locFanElecPower / vsCoil.RunFrac -
+                                      vsCoil.HPWHCondPumpElecNomPower;
                     if (OperatingHeatingPower > 0.0) TankHeatingCOP = TotalTankHeatingCapacity / OperatingHeatingPower;
                 } else {
-                    CompressorPower = OperatingHeatingPower - locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
-                    if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
+                    CompressorPower = OperatingHeatingPower - locFanElecPower / vsCoil.RunFrac;
+                    if ((OperatingHeatingPower + vsCoil.HPWHCondPumpElecNomPower) > 0.0)
                         TankHeatingCOP = TotalTankHeatingCapacity /
-                                         (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
+                                         (OperatingHeatingPower + vsCoil.HPWHCondPumpElecNomPower);
                 }
             } else {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
+                if (vsCoil.CondPumpPowerInCOP) {
                     //       make sure fan power is full load fan power
-                    CompressorPower = OperatingHeatingPower - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
-                    if ((OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac) > 0.0)
+                    CompressorPower = OperatingHeatingPower - vsCoil.HPWHCondPumpElecNomPower;
+                    if ((OperatingHeatingPower + locFanElecPower / vsCoil.RunFrac) > 0.0)
                         TankHeatingCOP = TotalTankHeatingCapacity /
-                                         (OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
+                                         (OperatingHeatingPower + locFanElecPower / vsCoil.RunFrac);
                 } else {
                     CompressorPower = OperatingHeatingPower;
-                    if ((OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
-                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
+                    if ((OperatingHeatingPower + locFanElecPower / vsCoil.RunFrac +
+                         vsCoil.HPWHCondPumpElecNomPower) > 0.0)
                         TankHeatingCOP = TotalTankHeatingCapacity /
-                                         (OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
-                                          state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
+                                         (OperatingHeatingPower + locFanElecPower / vsCoil.RunFrac +
+                                          vsCoil.HPWHCondPumpElecNomPower);
                 }
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
+            if (vsCoil.CondPumpHeatInCapacity) {
                 EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
             } else {
                 EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
             }
 
-            CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
-                                          state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
+            CBFSpeed = DXCoils::AdjustCBF(vsCoil.MSRatedCBF(SpeedCal),
+                                          vsCoil.MSRatedAirMassFlowRate(SpeedCal),
                                           state.dataVariableSpeedCoils->LoadSideMassFlowRate);
 
         } else {
             AirMassFlowRatio =
-                state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
+                state.dataVariableSpeedCoils->LoadSideMassFlowRate / vsCoil.DesignAirMassFlowRate;
             WaterMassFlowRatio =
-                state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
-            AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
-                    (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
+                state.dataVariableSpeedCoils->SourceSideMassFlowRate / vsCoil.DesignWaterMassFlowRate;
+            AoEff = vsCoil.MSEffectiveAo(SpeedCal) * SpeedRatio +
+                    (1.0 - SpeedRatio) * vsCoil.MSEffectiveAo(SpeedCal - 1);
             CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
 
             // calculate low speed
             SpeedCal = SpeedNum - 1;
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
+            vsCoil.HPWHCondPumpElecNomPower =
+                vsCoil.MSWHPumpPower(SpeedCal);
             COPTempModFac = Curve::CurveValue(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                              vsCoil.MSEIRFTemp(SpeedCal),
                                               InletAirTemp,
                                               state.dataVariableSpeedCoils->SourceSideInletTemp);
             COPAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
             COPWaterFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
 
-            COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
+            COP = vsCoil.MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
 
             TOTCAPTempModFac = Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
+                                                 vsCoil.MSCCapFTemp(SpeedCal),
                                                  InletAirTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             //   Get capacity modifying factor (function of mass flow) for off-rated conditions
             TOTCAPAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
             // Get capacity modifying factor (function of mass flow) for off-rated conditions
             TOTCAPWaterFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
 
-            OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
+            OperatingHeatingCapacity = vsCoil.MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
                                        TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
 
             state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
@@ -6812,31 +6675,31 @@ namespace VariableSpeedCoils {
             // calculate upper speed
             SpeedCal = SpeedNum;
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
+            vsCoil.HPWHCondPumpElecNomPower =
+                vsCoil.MSWHPumpPower(SpeedCal);
             COPTempModFac = Curve::CurveValue(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                              vsCoil.MSEIRFTemp(SpeedCal),
                                               InletAirTemp,
                                               state.dataVariableSpeedCoils->SourceSideInletTemp);
             COPAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
             COPWaterFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
 
-            COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
+            COP = vsCoil.MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
 
             TOTCAPTempModFac = Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
+                                                 vsCoil.MSCCapFTemp(SpeedCal),
                                                  InletAirTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             //   Get capacity modifying factor (function of mass flow) for off-rated conditions
             TOTCAPAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
             // Get capacity modifying factor (function of mass flow) for off-rated conditions
             TOTCAPWaterFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
 
-            OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
+            OperatingHeatingCapacity = vsCoil.MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
                                        TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
 
             Winput2 = OperatingHeatingCapacity / COP;
@@ -6846,53 +6709,53 @@ namespace VariableSpeedCoils {
             state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
             OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
             OperatingHeatingCapacity = WHCAP2 * SpeedRatio + (1.0 - SpeedRatio) * WHCAP1;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum) * SpeedRatio +
-                (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum - 1);
+            vsCoil.HPWHCondPumpElecNomPower =
+                vsCoil.MSWHPumpPower(SpeedNum) * SpeedRatio +
+                (1.0 - SpeedRatio) * vsCoil.MSWHPumpPower(SpeedNum - 1);
 
             OperatingHeatingCOP = OperatingHeatingCapacity / OperatingHeatingPower;
             TankHeatingCOP = OperatingHeatingCOP;
 
-            PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
-                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
+            PumpHeatToWater = vsCoil.HPWHCondPumpElecNomPower *
+                              vsCoil.HPWHCondPumpFracToWater;
 
             // account for pump heat if not included in total water heating capacity
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
+            if (vsCoil.CondPumpHeatInCapacity) {
                 TotalTankHeatingCapacity = OperatingHeatingCapacity;
             } else {
                 TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
             }
 
-            Real64 HPRTF = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
+            Real64 HPRTF = vsCoil.RunFrac;
             // calculate evaporator total cooling capacity
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
+            if (vsCoil.FanPowerIncludedInCOP) {
+                if (vsCoil.CondPumpPowerInCOP) {
                     //       make sure fan power is full load fan power
                     CompressorPower = OperatingHeatingPower - locFanElecPower / HPRTF -
-                                      state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
+                                      vsCoil.HPWHCondPumpElecNomPower;
                     if (OperatingHeatingPower > 0.0) TankHeatingCOP = TotalTankHeatingCapacity / OperatingHeatingPower;
                 } else {
                     CompressorPower = OperatingHeatingPower - locFanElecPower / HPRTF;
-                    if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
+                    if ((OperatingHeatingPower + vsCoil.HPWHCondPumpElecNomPower) > 0.0)
                         TankHeatingCOP = TotalTankHeatingCapacity /
-                                         (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
+                                         (OperatingHeatingPower + vsCoil.HPWHCondPumpElecNomPower);
                 }
             } else {
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
+                if (vsCoil.CondPumpPowerInCOP) {
                     //       make sure fan power is full load fan power
-                    CompressorPower = OperatingHeatingPower - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
+                    CompressorPower = OperatingHeatingPower - vsCoil.HPWHCondPumpElecNomPower;
                     if ((OperatingHeatingPower + locFanElecPower / HPRTF) > 0.0)
                         TankHeatingCOP = TotalTankHeatingCapacity / (OperatingHeatingPower + locFanElecPower / HPRTF);
                 } else {
                     CompressorPower = OperatingHeatingPower;
                     if ((OperatingHeatingPower + locFanElecPower / HPRTF +
-                         state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
+                         vsCoil.HPWHCondPumpElecNomPower) > 0.0)
                         TankHeatingCOP = TotalTankHeatingCapacity / (OperatingHeatingPower + locFanElecPower / HPRTF +
-                                                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
+                                                                     vsCoil.HPWHCondPumpElecNomPower);
                 }
             }
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
+            if (vsCoil.CondPumpHeatInCapacity) {
                 EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
             } else {
                 EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
@@ -6942,16 +6805,16 @@ namespace VariableSpeedCoils {
         // total heating COP including compressor, fan, and condenser pump
         state.dataVariableSpeedCoils->VSHPWHHeatingCOP = TankHeatingCOP;
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = TotalTankHeatingCapacity * PartLoadRatio;
+        vsCoil.TotalHeatingEnergyRate = TotalTankHeatingCapacity * PartLoadRatio;
         // calculate total compressor plus condenser pump power, fan power reported in fan module
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
-            (CompressorPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) *
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
+        vsCoil.ElecWaterHeatingPower =
+            (CompressorPower + vsCoil.HPWHCondPumpElecNomPower) *
+            vsCoil.RunFrac;
 
         // pass the outputs for the cooling coil section
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
-            CrankcaseHeatingPower * (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
+        vsCoil.BasinHeaterPower = 0.0;
+        vsCoil.CrankcaseHeaterPower =
+            CrankcaseHeatingPower * (1.0 - vsCoil.RunFrac);
 
         // calculate coil outlet state variables
         state.dataVariableSpeedCoils->LoadSideOutletEnth =
@@ -6965,7 +6828,7 @@ namespace VariableSpeedCoils {
         MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
                                                   state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
                                                   0.9999,
-                                                  state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
+                                                  vsCoil.InletAirPressure,
                                                   RoutineName);
         MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
         if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
@@ -6980,20 +6843,20 @@ namespace VariableSpeedCoils {
         // Actual outlet conditions are "average" for time step
         if (fanOp == HVAC::FanOp::Continuous) {
             // continuous fan, cycling compressor
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
+            vsCoil.OutletAirEnthalpy =
                 PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
                 (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
+            vsCoil.OutletAirHumRat =
                 PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
                 (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
-                Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
+            vsCoil.OutletAirDBTemp =
+                Psychrometrics::PsyTdbFnHW(vsCoil.OutletAirEnthalpy,
+                                           vsCoil.OutletAirHumRat);
             state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
+            vsCoil.OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
+            vsCoil.OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
+            vsCoil.OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
             state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
         }
 
@@ -7002,73 +6865,73 @@ namespace VariableSpeedCoils {
         state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
         // count the powr separately
         state.dataVariableSpeedCoils->Winput *=
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower &
+            vsCoil.RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower &
         //+ VarSpeedCoil(DXCoilNum)%BasinHeaterPower + VarSpeedCoil(DXCoilNum)%EvapCondPumpElecPower
         state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
 
         // Update heat pump data structure
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; // water heating pump power
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
+        vsCoil.HPWHCondPumpElecNomPower =
+            vsCoil.HPWHCondPumpElecNomPower *
+            vsCoil.RunFrac; // water heating pump power
+        vsCoil.Power = state.dataVariableSpeedCoils->Winput;
+        vsCoil.QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
+        vsCoil.QSensible = state.dataVariableSpeedCoils->QSensible;
+        vsCoil.QLatent =
             state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
+        vsCoil.QSource = state.dataVariableSpeedCoils->QSource;
+        vsCoil.Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
+        vsCoil.EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
+        vsCoil.EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
+        vsCoil.EnergyLatent =
             (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
+        vsCoil.EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
+        vsCoil.CrankcaseHeaterConsumption =
+            vsCoil.CrankcaseHeaterPower * TimeStepSysSec;
+        vsCoil.EvapWaterConsump = 0.0;
+        vsCoil.BasinHeaterConsumption = 0.0;
         // re-use EvapCondPumpElecConsumption to store WH pump energy consumption
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower * TimeStepSysSec;
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
+        vsCoil.EvapCondPumpElecConsumption =
+            vsCoil.HPWHCondPumpElecNomPower * TimeStepSysSec;
+        if (vsCoil.RunFrac == 0.0) {
+            vsCoil.COP = 0.0;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
+            vsCoil.COP =
                 state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
         }
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
+        vsCoil.PartLoadRatio = PartLoadRatio;
+        vsCoil.AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
         rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
                                                    state.dataEnvrn->OutBaroPress,
                                                    state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                    state.dataVariableSpeedCoils->LoadSideInletHumRat,
                                                    RoutineName);
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
+        vsCoil.AirVolFlowRate =
+            vsCoil.AirMassFlowRate / rhoair;
+        vsCoil.WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
         RhoWater = Psychrometrics::RhoH2O(InletWaterTemp); // initialize
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate / RhoWater;
+        vsCoil.WaterVolFlowRate =
+            vsCoil.WaterMassFlowRate / RhoWater;
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
+        vsCoil.OutletWaterTemp =
             state.dataVariableSpeedCoils->SourceSideInletTemp +
             state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpWater);
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
+        vsCoil.OutletWaterEnthalpy =
             state.dataVariableSpeedCoils->SourceSideInletEnth +
             state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
+        vsCoil.QWasteHeat = 0.0;
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater) // desuperheater doesn't save power and cooling energy variables
+        if (vsCoil.bIsDesuperheater) // desuperheater doesn't save power and cooling energy variables
         {
             // source side is the water side; load side is the air side
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
+            vsCoil.Power = 0.0;
+            vsCoil.QLoadTotal = 0.0;
+            vsCoil.QSensible = 0.0;
+            vsCoil.QLatent = 0.0;
+            vsCoil.Energy = 0.0;
+            vsCoil.EnergyLoadTotal = 0.0;
+            vsCoil.EnergySensible = 0.0;
+            vsCoil.EnergyLatent = 0.0;
+            vsCoil.CrankcaseHeaterConsumption = 0.0;
         }
     }
 
@@ -7133,37 +6996,41 @@ namespace VariableSpeedCoils {
         Real64 rhoair(0.0);         // entering air density
 
         // ADDED VARIABLES FOR air source coil
-        int MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
+
+        auto const &s_node = state.dataLoopNodes;
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+        
+        int MaxSpeed = vsCoil.NumOfSpeeds;
 
         //  LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
         if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
-                state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
+            vsCoil.AirMassFlowRate =
+                state.dataLoopNodes->Node(vsCoil.AirInletNodeNum).MassFlowRate / PartLoadRatio;
         }
 
-        state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
-        state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
-        state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
+        state.dataVariableSpeedCoils->LoadSideMassFlowRate = vsCoil.AirMassFlowRate;
+        state.dataVariableSpeedCoils->LoadSideInletDBTemp = vsCoil.InletAirDBTemp;
+        state.dataVariableSpeedCoils->LoadSideInletHumRat = vsCoil.InletAirHumRat;
 
         state.dataVariableSpeedCoils->LoadSideInletWBTemp = Psychrometrics::PsyTwbFnTdbWPb(state,
                                                                                            state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                                                            state.dataVariableSpeedCoils->LoadSideInletHumRat,
                                                                                            state.dataEnvrn->OutBaroPress,
                                                                                            RoutineName);
-        state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
+        state.dataVariableSpeedCoils->LoadSideInletEnth = vsCoil.InletAirEnthalpy;
         Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat); // Specific heat of air [J/kg_C]
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+        if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
             // Get condenser outdoor node info from DX Heating Coil
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum != 0) {
+            if (vsCoil.CondenserInletNodeNum != 0) {
                 state.dataVariableSpeedCoils->OutdoorDryBulb =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Temp;
                 state.dataVariableSpeedCoils->OutdoorHumRat =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).HumRat;
                 state.dataVariableSpeedCoils->OutdoorPressure =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).Press;
                 state.dataVariableSpeedCoils->OutdoorWetBulb =
-                    state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb;
+                    state.dataLoopNodes->Node(vsCoil.CondenserInletNodeNum).OutAirWetBulb;
             } else {
                 state.dataVariableSpeedCoils->OutdoorDryBulb = state.dataEnvrn->OutDryBulbTemp;
                 state.dataVariableSpeedCoils->OutdoorHumRat = state.dataEnvrn->OutHumRat;
@@ -7177,41 +7044,41 @@ namespace VariableSpeedCoils {
             CpSource = Psychrometrics::PsyCpAirFnW(state.dataEnvrn->OutHumRat);
 
             // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
-            if (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
-                state.dataVariableSpeedCoils->CrankcaseHeatingPower = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
+            if (state.dataVariableSpeedCoils->OutdoorDryBulb < vsCoil.MaxOATCrankcaseHeater) {
+                state.dataVariableSpeedCoils->CrankcaseHeatingPower = vsCoil.CrankcaseHeaterCapacity;
+                if (vsCoil.CrankcaseHeaterCapacityCurveIndex > 0) {
                     state.dataVariableSpeedCoils->CrankcaseHeatingPower *=
                         Curve::CurveValue(state,
-                                          state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
+                                          vsCoil.CrankcaseHeaterCapacityCurveIndex,
                                           state.dataEnvrn->OutDryBulbTemp);
                 }
             } else {
                 state.dataVariableSpeedCoils->CrankcaseHeatingPower = 0.0;
             }
         } else {
-            state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
-            state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
-            state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
-            CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
+            state.dataVariableSpeedCoils->SourceSideMassFlowRate = vsCoil.WaterMassFlowRate;
+            state.dataVariableSpeedCoils->SourceSideInletTemp = vsCoil.InletWaterTemp;
+            state.dataVariableSpeedCoils->SourceSideInletEnth = vsCoil.InletWaterEnthalpy;
+            CpSource = state.dataPlnt->PlantLoop(vsCoil.plantLoc.loopNum)
                            .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp);
         }
 
         // Check for flows, do not perform simulation if no flow in load side or source side.
         if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
+            vsCoil.SimFlag = false;
             return;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
+            vsCoil.SimFlag = true;
         }
 
-        if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
-            (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor)) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
+        if ((vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) &&
+            (state.dataVariableSpeedCoils->OutdoorDryBulb < vsCoil.MinOATCompressor)) {
+            vsCoil.SimFlag = false;
             return;
         }
 
         if (compressorOp == HVAC::CompressorOp::Off) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
+            vsCoil.SimFlag = false;
             return;
         }
 
@@ -7221,10 +7088,10 @@ namespace VariableSpeedCoils {
             SpeedCal = SpeedNum;
         }
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
+        vsCoil.RunFrac = 1.0;
         state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
         if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
-            PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
+            PLF = Curve::CurveValue(state, vsCoil.PLFFPLR, PartLoadRatio);
             if (PLF < 0.7) {
                 PLF = 0.7;
             }
@@ -7232,174 +7099,174 @@ namespace VariableSpeedCoils {
                 state.dataHVACGlobal->OnOffFanPartLoadFraction =
                     PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
             // calculate the run time fraction
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
+            vsCoil.RunFrac = PartLoadRatio / PLF;
+            vsCoil.PartLoadRatio = PartLoadRatio;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
-            } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
+            if (vsCoil.RunFrac > 1.0) {
+                vsCoil.RunFrac = 1.0; // Reset coil runtime fraction to 1.0
+            } else if (vsCoil.RunFrac < 0.0) {
+                vsCoil.RunFrac = 0.0;
             }
         }
 
         if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
             AirMassFlowRatio =
-                state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
+                state.dataVariableSpeedCoils->LoadSideMassFlowRate / vsCoil.DesignAirMassFlowRate;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 WaterMassFlowRatio = 1.0;
             } else {
                 WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
+                                     vsCoil.DesignWaterMassFlowRate;
             }
 
             TotCapTempModFac = Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
+                                                 vsCoil.MSCCapFTemp(SpeedCal),
                                                  state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             TotCapAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 TotCapWaterFFModFac = 1.0;
             } else {
                 TotCapWaterFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
             }
 
-            state.dataVariableSpeedCoils->QLoadTotal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) *
+            state.dataVariableSpeedCoils->QLoadTotal = vsCoil.MSRatedTotCap(SpeedCal) *
                                                        TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal = TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
+            vsCoil.capModFacTotal = TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
             state.dataVariableSpeedCoils->TotRatedCapacity =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal); // for defrosting power cal
+                vsCoil.MSRatedTotCap(SpeedCal); // for defrosting power cal
 
             EIRTempModFac = Curve::CurveValue(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                              vsCoil.MSEIRFTemp(SpeedCal),
                                               state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                               state.dataVariableSpeedCoils->SourceSideInletTemp);
             EIRAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 EIRWaterFFModFac = 1.0;
             } else {
                 EIRWaterFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
             }
 
-            EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
+            EIR = (1.0 / vsCoil.MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
                   EIRWaterFFModFac;
             state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 QWasteHeat = 0.0;
             } else {
-                QWasteHeat = state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
+                QWasteHeat = state.dataVariableSpeedCoils->Winput * vsCoil.MSWasteHeatFrac(SpeedCal);
                 QWasteHeat *= Curve::CurveValue(state,
-                                                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
+                                                vsCoil.MSWasteHeat(SpeedCal),
                                                 state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                 state.dataVariableSpeedCoils->SourceSideInletTemp);
             }
 
         } else {
             AirMassFlowRatio =
-                state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
+                state.dataVariableSpeedCoils->LoadSideMassFlowRate / vsCoil.DesignAirMassFlowRate;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 WaterMassFlowRatio = 1.0;
             } else {
                 WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
-                                     state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
+                                     vsCoil.DesignWaterMassFlowRate;
             }
 
             SpeedCal = SpeedNum - 1;
             TotCapTempModFac = Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
+                                                 vsCoil.MSCCapFTemp(SpeedCal),
                                                  state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             TotCapAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 TotCapWaterFFModFac = 1.0;
             } else {
                 TotCapWaterFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
             }
 
-            QLoadTotal1 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
+            QLoadTotal1 = vsCoil.MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
                           TotCapWaterFFModFac;
 
             EIRTempModFac = Curve::CurveValue(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                              vsCoil.MSEIRFTemp(SpeedCal),
                                               state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                               state.dataVariableSpeedCoils->SourceSideInletTemp);
             EIRAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 EIRWaterFFModFac = 1.0;
             } else {
                 EIRWaterFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
             }
 
-            EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
+            EIR = (1.0 / vsCoil.MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
                   EIRWaterFFModFac;
             Winput1 = QLoadTotal1 * EIR;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 QWasteHeat1 = 0.0;
             } else {
-                QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
+                QWasteHeat1 = Winput1 * vsCoil.MSWasteHeatFrac(SpeedCal);
                 QWasteHeat1 *= Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
+                                                 vsCoil.MSWasteHeat(SpeedCal),
                                                  state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             }
 
             SpeedCal = SpeedNum;
             TotCapTempModFac = Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
+                                                 vsCoil.MSCCapFTemp(SpeedCal),
                                                  state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             TotCapAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 TotCapWaterFFModFac = 1.0;
             } else {
                 TotCapWaterFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
             }
 
-            QLoadTotal2 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
+            QLoadTotal2 = vsCoil.MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
                           TotCapWaterFFModFac;
 
             EIRTempModFac = Curve::CurveValue(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
+                                              vsCoil.MSEIRFTemp(SpeedCal),
                                               state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                               state.dataVariableSpeedCoils->SourceSideInletTemp);
             EIRAirFFModFac =
-                Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
+                Curve::CurveValue(state, vsCoil.MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 EIRWaterFFModFac = 1.0;
             } else {
                 EIRWaterFFModFac =
-                    Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
+                    Curve::CurveValue(state, vsCoil.MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
             }
 
-            EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
+            EIR = (1.0 / vsCoil.MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
                   EIRWaterFFModFac;
             Winput2 = QLoadTotal2 * EIR;
 
-            if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
                 QWasteHeat2 = 0.0;
             } else {
-                QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
+                QWasteHeat2 = Winput2 * vsCoil.MSWasteHeatFrac(SpeedCal);
                 QWasteHeat2 *= Curve::CurveValue(state,
-                                                 state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
+                                                 vsCoil.MSWasteHeat(SpeedCal),
                                                  state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                  state.dataVariableSpeedCoils->SourceSideInletTemp);
             }
@@ -7408,13 +7275,13 @@ namespace VariableSpeedCoils {
             state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
             QWasteHeat = QWasteHeat2 * SpeedRatio + (1.0 - SpeedRatio) * QWasteHeat1;
             state.dataVariableSpeedCoils->TotRatedCapacity =
-                state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * SpeedRatio +
-                (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1);
+                vsCoil.MSRatedTotCap(SpeedCal) * SpeedRatio +
+                (1.0 - SpeedRatio) * vsCoil.MSRatedTotCap(SpeedCal - 1);
         }
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0; // necessary to clear zero for water source coils
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;         // clear the defrost power
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+        vsCoil.CrankcaseHeaterPower = 0.0; // necessary to clear zero for water source coils
+        vsCoil.DefrostPower = 0.0;         // clear the defrost power
+        if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
             // Calculating adjustment factors for defrost
             // Calculate delta w through outdoor coil by assuming a coil temp of 0.82*DBT-9.7(F) per DOE2.1E
             state.dataVariableSpeedCoils->OutdoorCoilT = 0.82 * state.dataVariableSpeedCoils->OutdoorDryBulb - 8.589;
@@ -7429,10 +7296,10 @@ namespace VariableSpeedCoils {
             state.dataVariableSpeedCoils->FractionalDefrostTime = 0.0;
             state.dataVariableSpeedCoils->InputPowerMultiplier = 1.0;
             // Check outdoor temperature to determine of defrost is active
-            if (state.dataVariableSpeedCoils->OutdoorDryBulb <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost) {
+            if (state.dataVariableSpeedCoils->OutdoorDryBulb <= vsCoil.MaxOATDefrost) {
                 // Calculate defrost adjustment factors depending on defrost control type
-                if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == Timed) {
-                    state.dataVariableSpeedCoils->FractionalDefrostTime = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime;
+                if (vsCoil.DefrostControl == Timed) {
+                    state.dataVariableSpeedCoils->FractionalDefrostTime = vsCoil.DefrostTime;
                     if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
                         if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn &&
                             state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
@@ -7476,34 +7343,34 @@ namespace VariableSpeedCoils {
                     }
                 }
                 // correction fractional defrost time shorten by runtime fraction
-                state.dataVariableSpeedCoils->FractionalDefrostTime *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
+                state.dataVariableSpeedCoils->FractionalDefrostTime *= vsCoil.RunFrac;
 
                 if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
                     // Calculate defrost adjustment factors depending on defrost control strategy
-                    if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == ReverseCycle) {
+                    if (vsCoil.DefrostStrategy == ReverseCycle) {
                         state.dataVariableSpeedCoils->LoadDueToDefrost = (0.01 * state.dataVariableSpeedCoils->FractionalDefrostTime) *
                                                                          (7.222 - state.dataVariableSpeedCoils->OutdoorDryBulb) *
                                                                          (state.dataVariableSpeedCoils->TotRatedCapacity / 1.01667);
                         state.dataVariableSpeedCoils->DefrostEIRTempModFac =
                             Curve::CurveValue(state,
-                                              state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT,
+                                              vsCoil.DefrostEIRFT,
                                               max(15.555, state.dataVariableSpeedCoils->LoadSideInletWBTemp),
                                               max(15.555, state.dataVariableSpeedCoils->OutdoorDryBulb));
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower =
+                        vsCoil.DefrostPower =
                             state.dataVariableSpeedCoils->DefrostEIRTempModFac * (state.dataVariableSpeedCoils->TotRatedCapacity / 1.01667) *
                             state.dataVariableSpeedCoils->FractionalDefrostTime;
                     } else { // Defrost strategy is resistive
-                        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower =
-                            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity *
+                        vsCoil.DefrostPower =
+                            vsCoil.DefrostCapacity *
                             state.dataVariableSpeedCoils->FractionalDefrostTime;
                     }
                 } else { // Defrost is not active because (OutDryBulbTemp > VarSpeedCoil(DXCoilNum).MaxOATDefrost)
-                    state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
+                    vsCoil.DefrostPower = 0.0;
                 }
             }
 
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
-                state.dataVariableSpeedCoils->CrankcaseHeatingPower * (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
+            vsCoil.CrankcaseHeaterPower =
+                state.dataVariableSpeedCoils->CrankcaseHeatingPower * (1.0 - vsCoil.RunFrac);
             //! Modify total heating capacity based on defrost heating capacity multiplier
             //! MaxHeatCap passed from parent object VRF Condenser and is used to limit capacity of TU's to that available from condenser
             //  IF(PRESENT(MaxHeatCap))THEN
@@ -7539,21 +7406,21 @@ namespace VariableSpeedCoils {
         // Actual outlet conditions are "average" for time step
         if (fanOp == HVAC::FanOp::Continuous) {
             // continuous fan, cycling compressor
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
+            vsCoil.OutletAirEnthalpy =
                 PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
                 (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
+            vsCoil.OutletAirHumRat =
                 PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
                 (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
-                Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
+            vsCoil.OutletAirDBTemp =
+                Psychrometrics::PsyTdbFnHW(vsCoil.OutletAirEnthalpy,
+                                           vsCoil.OutletAirHumRat);
             state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
         } else {
             // default to cycling fan, cycling compressor
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
+            vsCoil.OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
+            vsCoil.OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
+            vsCoil.OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
             state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
         }
 
@@ -7562,55 +7429,55 @@ namespace VariableSpeedCoils {
         state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
         // count the powr separately
         state.dataVariableSpeedCoils->Winput *=
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower
+            vsCoil.RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower
         state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
         QWasteHeat *= PartLoadRatio;
 
         // Update heat pump data structure
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower * TimeStepSysSec;
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
+        vsCoil.Power = state.dataVariableSpeedCoils->Winput;
+        vsCoil.QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
+        vsCoil.QSensible = state.dataVariableSpeedCoils->QSensible;
+        vsCoil.QSource = state.dataVariableSpeedCoils->QSource;
+        vsCoil.Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
+        vsCoil.EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
+        vsCoil.EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
+        vsCoil.EnergyLatent = 0.0;
+        vsCoil.EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
+        vsCoil.CrankcaseHeaterConsumption =
+            vsCoil.CrankcaseHeaterPower * TimeStepSysSec;
+        vsCoil.DefrostConsumption =
+            vsCoil.DefrostPower * TimeStepSysSec;
+        if (vsCoil.RunFrac == 0.0) {
+            vsCoil.COP = 0.0;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
+            vsCoil.COP =
                 state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
         }
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
+        vsCoil.PartLoadRatio = PartLoadRatio;
+        vsCoil.AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
         rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
                                                    state.dataEnvrn->OutBaroPress,
                                                    state.dataVariableSpeedCoils->LoadSideInletDBTemp,
                                                    state.dataVariableSpeedCoils->LoadSideInletHumRat,
                                                    RoutineName);
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
+        vsCoil.AirVolFlowRate =
+            vsCoil.AirMassFlowRate / rhoair;
 
-        if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
+        if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+            vsCoil.WaterMassFlowRate = 0.0;
+            vsCoil.OutletWaterTemp = 0.0;
+            vsCoil.OutletWaterEnthalpy = 0.0;
         } else {
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
+            vsCoil.WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
+            vsCoil.OutletWaterTemp =
                 state.dataVariableSpeedCoils->SourceSideInletTemp -
                 state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
-            state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
+            vsCoil.OutletWaterEnthalpy =
                 state.dataVariableSpeedCoils->SourceSideInletEnth -
                 state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
         }
 
-        state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
+        vsCoil.QWasteHeat = QWasteHeat;
     }
 
     Real64 GetCoilCapacityVariableSpeed(EnergyPlusData &state,
@@ -7876,6 +7743,19 @@ namespace VariableSpeedCoils {
         return NodeNumber;
     }
 
+    int GetCoilInletNodeVariableSpeed(EnergyPlusData &state,
+                                      std::string const &CoilName
+    )
+    {
+        if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
+            GetVarSpeedCoilInput(state);
+            state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
+        }
+
+        int WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
+        return (WhichCoil == 0) ? 0 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirInletNodeNum;
+    }
+  
     int GetCoilOutletNodeVariableSpeed(EnergyPlusData &state,
                                        std::string const &CoilType, // must match coil types in this module
                                        std::string const &CoilName, // must match coil names for the coil type
@@ -7917,6 +7797,20 @@ namespace VariableSpeedCoils {
         return NodeNumber;
     }
 
+    int GetCoilOutletNodeVariableSpeed(EnergyPlusData &state,
+                                       std::string const &CoilName // must match coil names for the coil type
+    )
+    {
+        // Obtains and Allocates WatertoAirHP related parameters from input file
+        if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
+            GetVarSpeedCoilInput(state);
+            state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
+        }
+
+        int WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
+        return (WhichCoil == 0) ? 0 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirOutletNodeNum;
+    }
+  
     int GetVSCoilCondenserInletNode(EnergyPlusData &state,
                                     std::string const &CoilName, // must match coil names for the coil type
                                     bool &ErrorsFound            // set to true if problem
@@ -8014,20 +7908,20 @@ namespace VariableSpeedCoils {
     Real64 GetVSCoilRatedSourceTemp(EnergyPlusData &state, int const CoilIndex)
     {
         Real64 RatedSourceTemp = 0.0;
-        switch (state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).VSCoilType) {
-        case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
+        switch (state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).coilType) {
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
             RatedSourceTemp = RatedInletWaterTemp;
         } break;
-        case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
             RatedSourceTemp = RatedInletWaterTempHeat;
         } break;
-        case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
+        case HVAC::CoilType::WaterHeatingAWHPVariableSpeed: {
             RatedSourceTemp = state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).WHRatedInletWaterTemp;
         } break;
-        case HVAC::Coil_CoolingAirToAirVariableSpeed: {
+        case HVAC::CoilType::CoolingDXVariableSpeed: {
             RatedSourceTemp = RatedAmbAirTemp;
         } break;
-        case HVAC::Coil_HeatingAirToAirVariableSpeed: {
+        case HVAC::CoilType::HeatingDXVariableSpeed: {
             RatedSourceTemp = RatedAmbAirTempHeat;
         } break;
         default: {
@@ -8037,36 +7931,14 @@ namespace VariableSpeedCoils {
         return RatedSourceTemp;
     }
 
-    void SetVarSpeedCoilData(EnergyPlusData &state,
-                             int const WSHPNum,                               // Number of OA Controller
-                             bool &ErrorsFound,                               // Set to true if certain errors found
-                             ObjexxFCL::Optional_int CompanionCoolingCoilNum, // Index to cooling coil for heating coil = SimpleWSHPNum
-                             ObjexxFCL::Optional_int CompanionHeatingCoilNum, // Index to heating coil for cooling coil = SimpleWSHPNum
-                             ObjexxFCL::Optional_int MSHPDesignSpecIndex      // index to UnitarySystemPerformance:Multispeed object
+    void SetCoilData(EnergyPlusData &state,
+                     int const WSHPNum,                               // Number of OA Controller
+                     ObjexxFCL::Optional_int CompanionCoolingCoilNum, // Index to cooling coil for heating coil = SimpleWSHPNum
+                     ObjexxFCL::Optional_int CompanionHeatingCoilNum, // Index to heating coil for cooling coil = SimpleWSHPNum
+                     ObjexxFCL::Optional_int MSHPDesignSpecIndex      // index to UnitarySystemPerformance:Multispeed object
     )
     {
-
-        // SUBROUTINE INFORMATION:
-        //       AUTHOR         Bo Shen, based on WaterToAirHeatPumpSimple:SetWSHPData
-        //       DATE WRITTEN   March 2012
-
-        // PURPOSE OF THIS SUBROUTINE:
-        // This routine was designed to "push" information from a parent object to this WSHP coil object.
-
-        // Obtains and Allocates WatertoAirHP related parameters from input file
-        if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
-            GetVarSpeedCoilInput(state);
-            state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
-        }
-
-        if (WSHPNum <= 0 || WSHPNum > state.dataVariableSpeedCoils->NumVarSpeedCoils) {
-            ShowSevereError(state,
-                            format("SetVarSpeedCoilData: called with VS WSHP Coil Number out of range={} should be >0 and <{}",
-                                   WSHPNum,
-                                   state.dataVariableSpeedCoils->NumVarSpeedCoils));
-            ErrorsFound = true;
-            return;
-        }
+        assert(WSHPNum > 0 && WSHPNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
 
         if (present(CompanionCoolingCoilNum)) {
             state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).CompanionCoolingCoilNum = CompanionCoolingCoilNum;
@@ -8099,42 +7971,42 @@ namespace VariableSpeedCoils {
         // Using/Aliasing
         Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
 
-        auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
 
         // WatertoAirHP(DXCoilNum)%SimFlag=.FALSE.
-        if (!varSpeedCoil.SimFlag) {
+        if (!vsCoil.SimFlag) {
             // Heatpump is off; just pass through conditions
-            varSpeedCoil.Power = 0.0;
-            varSpeedCoil.QLoadTotal = 0.0;
-            varSpeedCoil.QSensible = 0.0;
-            varSpeedCoil.QLatent = 0.0;
-            varSpeedCoil.QSource = 0.0;
-            varSpeedCoil.Energy = 0.0;
-            varSpeedCoil.EnergyLoadTotal = 0.0;
-            varSpeedCoil.EnergySensible = 0.0;
-            varSpeedCoil.EnergyLatent = 0.0;
-            varSpeedCoil.EnergySource = 0.0;
-            varSpeedCoil.COP = 0.0;
-            varSpeedCoil.RunFrac = 0.0;
-            varSpeedCoil.PartLoadRatio = 0.0;
-
-            varSpeedCoil.OutletAirDBTemp = varSpeedCoil.InletAirDBTemp;
-            varSpeedCoil.OutletAirHumRat = varSpeedCoil.InletAirHumRat;
-            varSpeedCoil.OutletAirEnthalpy = varSpeedCoil.InletAirEnthalpy;
-            varSpeedCoil.OutletWaterTemp = varSpeedCoil.InletWaterTemp;
-            varSpeedCoil.OutletWaterEnthalpy = varSpeedCoil.InletWaterEnthalpy;
-        }
-
-        int AirInletNode = varSpeedCoil.AirInletNodeNum;
-        int WaterInletNode = varSpeedCoil.WaterInletNodeNum;
-        int AirOutletNode = varSpeedCoil.AirOutletNodeNum;
-        int WaterOutletNode = varSpeedCoil.WaterOutletNodeNum;
+            vsCoil.Power = 0.0;
+            vsCoil.QLoadTotal = 0.0;
+            vsCoil.QSensible = 0.0;
+            vsCoil.QLatent = 0.0;
+            vsCoil.QSource = 0.0;
+            vsCoil.Energy = 0.0;
+            vsCoil.EnergyLoadTotal = 0.0;
+            vsCoil.EnergySensible = 0.0;
+            vsCoil.EnergyLatent = 0.0;
+            vsCoil.EnergySource = 0.0;
+            vsCoil.COP = 0.0;
+            vsCoil.RunFrac = 0.0;
+            vsCoil.PartLoadRatio = 0.0;
+
+            vsCoil.OutletAirDBTemp = vsCoil.InletAirDBTemp;
+            vsCoil.OutletAirHumRat = vsCoil.InletAirHumRat;
+            vsCoil.OutletAirEnthalpy = vsCoil.InletAirEnthalpy;
+            vsCoil.OutletWaterTemp = vsCoil.InletWaterTemp;
+            vsCoil.OutletWaterEnthalpy = vsCoil.InletWaterEnthalpy;
+        }
+
+        int AirInletNode = vsCoil.AirInletNodeNum;
+        int WaterInletNode = vsCoil.WaterInletNodeNum;
+        int AirOutletNode = vsCoil.AirOutletNodeNum;
+        int WaterOutletNode = vsCoil.WaterOutletNodeNum;
 
         // Set the air outlet  nodes of the WatertoAirHPSimple
         state.dataLoopNodes->Node(AirOutletNode).MassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate; // LoadSideMassFlowRate
-        state.dataLoopNodes->Node(AirOutletNode).Temp = varSpeedCoil.OutletAirDBTemp;
-        state.dataLoopNodes->Node(AirOutletNode).HumRat = varSpeedCoil.OutletAirHumRat;
-        state.dataLoopNodes->Node(AirOutletNode).Enthalpy = varSpeedCoil.OutletAirEnthalpy;
+        state.dataLoopNodes->Node(AirOutletNode).Temp = vsCoil.OutletAirDBTemp;
+        state.dataLoopNodes->Node(AirOutletNode).HumRat = vsCoil.OutletAirHumRat;
+        state.dataLoopNodes->Node(AirOutletNode).Enthalpy = vsCoil.OutletAirEnthalpy;
 
         // Set the air outlet nodes for properties that just pass through & not used
         state.dataLoopNodes->Node(AirOutletNode).Quality = state.dataLoopNodes->Node(AirInletNode).Quality;
@@ -8149,15 +8021,15 @@ namespace VariableSpeedCoils {
         // Set the water outlet nodes for properties that just pass through & not used
         if (WaterInletNode != 0 && WaterOutletNode != 0) {
             PlantUtilities::SafeCopyPlantNode(state, WaterInletNode, WaterOutletNode);
-            state.dataLoopNodes->Node(WaterOutletNode).Temp = varSpeedCoil.OutletWaterTemp;
-            state.dataLoopNodes->Node(WaterOutletNode).Enthalpy = varSpeedCoil.OutletWaterEnthalpy;
+            state.dataLoopNodes->Node(WaterOutletNode).Temp = vsCoil.OutletWaterTemp;
+            state.dataLoopNodes->Node(WaterOutletNode).Enthalpy = vsCoil.OutletWaterEnthalpy;
         }
 
-        varSpeedCoil.Energy = varSpeedCoil.Power * TimeStepSysSec;
-        varSpeedCoil.EnergyLoadTotal = varSpeedCoil.QLoadTotal * TimeStepSysSec;
-        varSpeedCoil.EnergySensible = varSpeedCoil.QSensible * TimeStepSysSec;
-        varSpeedCoil.EnergyLatent = varSpeedCoil.QLatent * TimeStepSysSec;
-        varSpeedCoil.EnergySource = varSpeedCoil.QSource * TimeStepSysSec;
+        vsCoil.Energy = vsCoil.Power * TimeStepSysSec;
+        vsCoil.EnergyLoadTotal = vsCoil.QLoadTotal * TimeStepSysSec;
+        vsCoil.EnergySensible = vsCoil.QSensible * TimeStepSysSec;
+        vsCoil.EnergyLatent = vsCoil.QLatent * TimeStepSysSec;
+        vsCoil.EnergySource = vsCoil.QSource * TimeStepSysSec;
 
         if (state.dataContaminantBalance->Contaminant.CO2Simulation) {
             state.dataLoopNodes->Node(AirOutletNode).CO2 = state.dataLoopNodes->Node(AirInletNode).CO2;
@@ -8167,41 +8039,41 @@ namespace VariableSpeedCoils {
             state.dataLoopNodes->Node(AirOutletNode).GenContam = state.dataLoopNodes->Node(AirInletNode).GenContam;
         }
 
-        if (varSpeedCoil.reportCoilFinalSizes) {
+        if (vsCoil.reportCoilFinalSizes) {
             if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
-                if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-                    varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // cooling coil
-                    state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
-                                                                                          varSpeedCoil.Name,
-                                                                                          varSpeedCoil.VarSpeedCoilType,
-                                                                                          varSpeedCoil.RatedCapCoolTotal,
-                                                                                          varSpeedCoil.RatedCapCoolSens,
-                                                                                          varSpeedCoil.RatedAirVolFlowRate,
-                                                                                          varSpeedCoil.RatedWaterMassFlowRate);
-                } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
-                           varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) { // heating coil
-                    state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
-                                                                                          varSpeedCoil.Name,
-                                                                                          varSpeedCoil.VarSpeedCoilType,
-                                                                                          varSpeedCoil.RatedCapHeat,
-                                                                                          varSpeedCoil.RatedCapHeat,
-                                                                                          varSpeedCoil.RatedAirVolFlowRate,
-                                                                                          varSpeedCoil.RatedWaterMassFlowRate);
+                if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+                    vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) { // cooling coil
+                    ReportCoilSelection::setCoilFinalSizes(state,
+                                                  vsCoil.Name,
+                                                  vsCoil.coilType,
+                                                  vsCoil.RatedCapCoolTotal,
+                                                  vsCoil.RatedCapCoolSens,
+                                                  vsCoil.RatedAirVolFlowRate,
+                                                  vsCoil.RatedWaterMassFlowRate);
+                } else if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit ||
+                           vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) { // heating coil
+                    ReportCoilSelection::setCoilFinalSizes(state,
+                                                  vsCoil.Name,
+                                                  vsCoil.coilType,
+                                                  vsCoil.RatedCapHeat,
+                                                  vsCoil.RatedCapHeat,
+                                                  vsCoil.RatedAirVolFlowRate,
+                                                  vsCoil.RatedWaterMassFlowRate);
                 }
-                varSpeedCoil.reportCoilFinalSizes = false;
+                vsCoil.reportCoilFinalSizes = false;
             }
         }
-        if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
-            varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+        if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit ||
+            vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
             //  Add power to global variable so power can be summed by parent object
-            state.dataHVACGlobal->DXElecCoolingPower = varSpeedCoil.Power;
-        } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
+            state.dataHVACGlobal->DXElecCoolingPower = vsCoil.Power;
+        } else if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit) {
             //  Add power to global variable so power can be summed by parent object
-            state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power;
-        } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
+            state.dataHVACGlobal->DXElecHeatingPower = vsCoil.Power;
+        } else if (vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
             //  Add power to global variable so power can be summed by parent object
-            state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power + varSpeedCoil.CrankcaseHeaterPower;
-            state.dataHVACGlobal->DefrostElecPower = varSpeedCoil.DefrostPower;
+            state.dataHVACGlobal->DXElecHeatingPower = vsCoil.Power + vsCoil.CrankcaseHeaterPower;
+            state.dataHVACGlobal->DefrostElecPower = vsCoil.DefrostPower;
         }
     }
 
@@ -8256,11 +8128,13 @@ namespace VariableSpeedCoils {
         Real64 Error;    // Error for iteration (DO) loop
         Real64 LHRmult;  // Latent Heat Ratio (LHR) multiplier. The effective latent heat ratio LHR = (1-SHRss)*LHRmult
 
-        Real64 Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated; // [s]
-        Real64 Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
-        Real64 MaxONOFFCyclesperHour = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour;           // [cycles/hr]
-        Real64 LatentCapacityTimeConstant = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant; // [s]
-        Real64 FanDelayTime = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime;                             // [s]
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
+        
+        Real64 Twet_Rated = vsCoil.Twet_Rated; // [s]
+        Real64 Gamma_Rated = vsCoil.Gamma_Rated;
+        Real64 MaxONOFFCyclesperHour = vsCoil.MaxONOFFCyclesperHour;           // [cycles/hr]
+        Real64 LatentCapacityTimeConstant = vsCoil.LatentCapacityTimeConstant; // [s]
+        Real64 FanDelayTime = vsCoil.FanDelayTime;                             // [s]
 
         //  No moisture evaporation (latent degradation) occurs for runtime fraction of 1.0
         //  All latent degradation model parameters cause divide by 0.0 if not greater than 0.0
@@ -8486,6 +8360,122 @@ namespace VariableSpeedCoils {
         return state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio;
     }
 
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName)
+    {
+        if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
+            GetVarSpeedCoilInput(state);
+            state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
+        }
+
+        return Util::FindItemInList(coilName, state.dataVariableSpeedCoils->VarSpeedCoil);
+    }
+
+    int GetCoilPLFFPLR(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        return state.dataVariableSpeedCoils->VarSpeedCoil(coilNum).PLFFPLR;
+    }
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(coilNum);
+        
+        if (vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit || 
+            vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed) {
+            return vsCoil.RatedCapHeat;
+        } else if (vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
+            return vsCoil.RatedCapWH;
+        } else {
+            return vsCoil.RatedCapCoolTotal;
+        }
+    }
+  
+    int GetCoilCapFTCurve(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(coilNum);
+        return vsCoil.MSCCapFTemp(vsCoil.NumOfSpeeds);
+    }
+
+    Real64 GetCoilAirFlowRate(EnergyPlusData &state, int coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        auto const &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(coilNum);
+        if (vsCoil.coilType == HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit || 
+            vsCoil.coilType == HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit || 
+            vsCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed ||
+            vsCoil.coilType == HVAC::CoilType::HeatingDXVariableSpeed || 
+            vsCoil.coilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed) {
+            if (vsCoil.RatedAirVolFlowRate == DataSizing::AutoSize) { // means autosize
+                return vsCoil.RatedAirVolFlowRate;
+            } else {
+                return vsCoil.MSRatedAirVolFlowRate(vsCoil.NumOfSpeeds) / vsCoil.MSRatedAirVolFlowRate(vsCoil.NormSpedLevel) *
+                  vsCoil.RatedAirVolFlowRate;
+            } // use largest air flow rate
+        } else {
+            return -1000.0; // Is this possible?
+        }
+    }
+
+    int GetCoilNumOfSpeeds(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        return state.dataVariableSpeedCoils->VarSpeedCoil(coilNum).NumOfSpeeds;
+    }
+  
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        return state.dataVariableSpeedCoils->VarSpeedCoil(coilNum).AirInletNodeNum;
+    }
+
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        return state.dataVariableSpeedCoils->VarSpeedCoil(coilNum).AirOutletNodeNum;
+    }
+
+    Real64 GetCoilRatedSourceTemp(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        auto const &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(coilNum);
+        
+        switch (vsCoil.coilType) {
+        case HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit: {
+            return RatedInletWaterTemp;
+        } break;
+        case HVAC::CoilType::HeatingWAHPVariableSpeedEquationFit: {
+            return RatedInletWaterTempHeat;
+        } break;
+        case HVAC::CoilType::WaterHeatingAWHPVariableSpeed: {
+            return vsCoil.WHRatedInletWaterTemp;
+        } break;
+        case HVAC::CoilType::CoolingDXVariableSpeed: {
+            return RatedAmbAirTemp;
+        } break;
+        case HVAC::CoilType::HeatingDXVariableSpeed: {
+            return RatedAmbAirTempHeat;
+        } break;
+        default: {
+            assert(false);
+            return -1000.0;
+        } break;
+        }
+    }
+
+    Real64 GetCoilMinOATCompressor(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        return state.dataVariableSpeedCoils->VarSpeedCoil(coilNum).MinOATCompressor;
+    }
+
+    int GetCoilCondenserInletNode(EnergyPlusData &state, int const coilNum) 
+    {
+        assert(coilNum > 0 && coilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils);
+        return state.dataVariableSpeedCoils->VarSpeedCoil(coilNum).CondenserInletNodeNum;
+    }
+
 } // namespace VariableSpeedCoils
 
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/VariableSpeedCoils.hh b/src/EnergyPlus/VariableSpeedCoils.hh
index 9227455ee66..471686aa3d7 100644
--- a/src/EnergyPlus/VariableSpeedCoils.hh
+++ b/src/EnergyPlus/VariableSpeedCoils.hh
@@ -73,7 +73,7 @@ namespace VariableSpeedCoils {
     {
         // Members
         std::string Name;              // Name of the  Coil
-        std::string VarSpeedCoilType;  // type of coil
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;
         int NumOfSpeeds;               // Number of speeds
         int NormSpedLevel;             // Nominal speed level
         Real64 RatedWaterVolFlowRate;  // Rated/Ref Water Volumetric Flow Rate [m3/s]
@@ -90,7 +90,7 @@ namespace VariableSpeedCoils {
         Real64 LatentCapacityTimeConstant; // Latent capacity time constant [s]
         int PLFFPLR;                       // index of part load curve as a function of part load ratio
         std::string CoolHeatType;          // Type of WatertoAirHP ie. Heating or Cooling
-        int VSCoilType;                    // type of component in plant
+
         bool SimFlag;                      // Heat Pump Simulation Flag
         Real64 DesignWaterMassFlowRate;    // design water mass flow rate [kg/s]
         Real64 DesignWaterVolFlowRate;     // design water volumetric flow rate [m3/s]
@@ -289,7 +289,7 @@ namespace VariableSpeedCoils {
             : NumOfSpeeds(2), NormSpedLevel(HVAC::MaxSpeedLevels), RatedWaterVolFlowRate(DataSizing::AutoSize),
               RatedWaterMassFlowRate(DataSizing::AutoSize), RatedAirVolFlowRate(DataSizing::AutoSize), RatedCapHeat(DataSizing::AutoSize),
               RatedCapCoolTotal(DataSizing::AutoSize), MaxONOFFCyclesperHour(0.0), Twet_Rated(0.0), Gamma_Rated(0.0), HOTGASREHEATFLG(0),
-              LatentCapacityTimeConstant(0.0), PLFFPLR(0), VSCoilType(0), SimFlag(false), DesignWaterMassFlowRate(0.0), DesignWaterVolFlowRate(0.0),
+              LatentCapacityTimeConstant(0.0), PLFFPLR(0), SimFlag(false), DesignWaterMassFlowRate(0.0), DesignWaterVolFlowRate(0.0),
               DesignAirMassFlowRate(0.0), DesignAirVolFlowRate(0.0), AirVolFlowRate(0.0), AirMassFlowRate(0.0), InletAirPressure(0.0),
               InletAirDBTemp(0.0), InletAirHumRat(0.0), InletAirEnthalpy(0.0), OutletAirDBTemp(0.0), OutletAirHumRat(0.0), OutletAirEnthalpy(0.0),
               WaterVolFlowRate(0.0), WaterMassFlowRate(0.0), InletWaterTemp(0.0), InletWaterEnthalpy(0.0), OutletWaterTemp(0.0),
@@ -363,6 +363,18 @@ namespace VariableSpeedCoils {
                                const Real64 OnOffAirFlowRatio = 1.0 // ratio of comp on to comp off air flow rate
     );
 
+    void SimVariableSpeedCoils(EnergyPlusData &state,
+                               int const coilNum,                  // Index for Component name
+                               HVAC::FanOp const fanOp,         // Continuous fan OR cycling compressor
+                               HVAC::CompressorOp compressorOp, // compressor on/off. 0 = off; 1= on
+                               Real64 const PartLoadFrac,
+                               int const SpeedNum,                  // compressor speed number
+                               Real64 const SpeedRatio,             // compressor speed ratio
+                               Real64 const SensLoad,               // Sensible demand load [W]
+                               Real64 const LatentLoad,             // Latent demand load [W]
+                               const Real64 OnOffAirFlowRatio = 1.0 // ratio of comp on to comp off air flow rate
+    );
+  
     void GetVarSpeedCoilInput(EnergyPlusData &state);
 
     // Beginning Initialization Section of the Module
@@ -403,72 +415,61 @@ namespace VariableSpeedCoils {
                                  int const SpeedNum               // Speed number, high bound, i.e. SpeedNum - 1 is the other side
     );
 
-    Real64 GetCoilCapacityVariableSpeed(EnergyPlusData &state,
-                                        std::string const &CoilType, // must match coil types in this module
-                                        std::string const &CoilName, // must match coil names for the coil type
-                                        bool &ErrorsFound            // set to true if problem
-    );
-
+#ifdef OLD_API
     int GetCoilIndexVariableSpeed(EnergyPlusData &state,
                                   std::string const &CoilType, // must match coil types in this module
                                   std::string const &CoilName, // must match coil names for the coil type
                                   bool &ErrorsFound            // set to true if problem
     );
+  
+    Real64 GetCoilCapacityVariableSpeed(EnergyPlusData &state,
+                                        std::string const &CoilType, // must match coil types in this module
+                                        std::string const &CoilName, // must match coil names for the coil type
+                                        bool &ErrorsFound            // set to true if problem
+    );
 
     Real64 GetCoilAirFlowRateVariableSpeed(EnergyPlusData &state,
                                            std::string const &CoilType, // must match coil types in this module
                                            std::string const &CoilName, // must match coil names for the coil type
                                            bool &ErrorsFound            // set to true if problem
-    );
+                                           );
 
-    int GetCoilInletNodeVariableSpeed(EnergyPlusData &state,
-                                      std::string const &CoilType, // must match coil types in this module
-                                      std::string const &CoilName, // must match coil names for the coil type
-                                      bool &ErrorsFound            // set to true if problem
+    int GetCoilAirInletNode(EnergyPlusData &state,
+                         std::string const &CoilType, // must match coil types in this module
+                         std::string const &CoilName, // must match coil names for the coil type
+                         bool &ErrorsFound            // set to true if problem
     );
 
-    int GetCoilOutletNodeVariableSpeed(EnergyPlusData &state,
-                                       std::string const &CoilType, // must match coil types in this module
-                                       std::string const &CoilName, // must match coil names for the coil type
-                                       bool &ErrorsFound            // set to true if problem
+    int GetCoilAirOutletNode(EnergyPlusData &state,
+                          std::string const &CoilType, // must match coil types in this module
+                          std::string const &CoilName, // must match coil names for the coil type
+                          bool &ErrorsFound            // set to true if problem
     );
 
-    int GetVSCoilCondenserInletNode(EnergyPlusData &state,
-                                    std::string const &CoilName, // must match coil names for the coil type
-                                    bool &ErrorsFound            // set to true if problem
+    int GetCoilCondenserInletNode(EnergyPlusData &state,
+                                  std::string const &CoilName, // must match coil names for the coil type
+                                  bool &ErrorsFound            // set to true if problem
     );
 
-    int GetVSCoilPLFFPLR(EnergyPlusData &state,
+    int GetCoilPLFFPLR(EnergyPlusData &state,
                          std::string const &CoilType, // must match coil types in this module
                          std::string const &CoilName, // must match coil names for the coil type
                          bool &ErrorsFound            // set to true if problem
     );
-
-    int GetVSCoilCapFTCurveIndex(EnergyPlusData &state,
-                                 int CoilIndex,    // must match coil names for the coil type
-                                 bool &ErrorsFound // set to true if problem
-    );
-
-    Real64 GetVSCoilMinOATCompressor(EnergyPlusData &state,
-                                     int const CoilIndex, // index to cooling coil
-                                     bool &ErrorsFound    // set to true if problem
-    );
-
-    int GetVSCoilNumOfSpeeds(EnergyPlusData &state,
-                             std::string const &CoilName, // must match coil names for the coil type
-                             bool &ErrorsFound            // set to true if problem
+ 
+    int GetCoilNumOfSpeeds(EnergyPlusData &state,
+                           std::string const &CoilName, // must match coil names for the coil type
+                           bool &ErrorsFound            // set to true if problem
     );
+#endif // OLD_API
 
-    Real64 GetVSCoilRatedSourceTemp(EnergyPlusData &state, int const CoilIndex);
-
-    void SetVarSpeedCoilData(EnergyPlusData &state,
-                             int const WSHPNum,                                   // Number of OA Controller
-                             bool &ErrorsFound,                                   // Set to true if certain errors found
-                             ObjexxFCL::Optional_int CompanionCoolingCoilNum = _, // Index to cooling coil for heating coil = SimpleWSHPNum
-                             ObjexxFCL::Optional_int CompanionHeatingCoilNum = _, // Index to heating coil for cooling coil = SimpleWSHPNum
-                             ObjexxFCL::Optional_int MSHPDesignSpecIndex = _      // index to UnitarySystemPerformance:Multispeed object
+    void SetCoilData(EnergyPlusData &state,
+                     int const WSHPNum,                                   // Number of OA Controller
+                     ObjexxFCL::Optional_int CompanionCoolingCoilNum = _, // Index to cooling coil for heating coil = SimpleWSHPNum
+                     ObjexxFCL::Optional_int CompanionHeatingCoilNum = _, // Index to heating coil for cooling coil = SimpleWSHPNum
+                     ObjexxFCL::Optional_int MSHPDesignSpecIndex = _      // index to UnitarySystemPerformance:Multispeed object
     );
-
+  
     void UpdateVarSpeedCoil(EnergyPlusData &state, int const DXCoilNum);
 
     Real64 CalcEffectiveSHR(EnergyPlusData &state,
@@ -518,11 +519,33 @@ namespace VariableSpeedCoils {
                           HVAC::FanOp const fanOp     // Continuous fan OR cycling compressor
     );
 
-    Real64 getVarSpeedPartLoadRatio(EnergyPlusData &state, int const DXCoilNum); // the number of the DX coil to mined for current PLR
+    int GetCoilIndex(EnergyPlusData &state, std::string const &CoilName);
+  
+    int GetCoilNumOfSpeeds(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilAirFlowRate(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
+      
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilCondenserInletNode(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilPLFFPLR(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilCapFTCurve(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilMinOATCompressor(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilRatedSourceTemp(EnergyPlusData &state, int const coilNum);
+
+    Real64 getVarSpeedPartLoadRatio(EnergyPlusData &state, int const coilNum); // the number of the DX coil to mined for current PLR
 
-    void setVarSpeedHPWHFanType(EnergyPlusData &state, int const dXCoilNum, HVAC::FanType fanType);
+    void setVarSpeedHPWHFanType(EnergyPlusData &state, int const coilNum, HVAC::FanType fanType);
 
-    void setVarSpeedHPWHFanIndex(EnergyPlusData &state, int const dXCoilNum, int const fanIndex);
+    void setVarSpeedHPWHFanIndex(EnergyPlusData &state, int const coilNum, int const fanIndex);
 
 } // namespace VariableSpeedCoils
 
diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc
index 1ec0fe27778..041e283d65a 100644
--- a/src/EnergyPlus/VentilatedSlab.cc
+++ b/src/EnergyPlus/VentilatedSlab.cc
@@ -211,9 +211,6 @@ namespace VentilatedSlab {
 
         static constexpr std::string_view routineName = "GetVentilatedSlabInput";
         // Using/Aliasing
-        auto &GetWaterCoilMaxFlowRate(WaterCoils::GetCoilMaxWaterFlowRate);
-        auto &GetSteamCoilMaxFlowRate(SteamCoils::GetCoilMaxWaterFlowRate);
-        auto &GetHXAssistedCoilFlowRate(HVACHXAssistedCoolingCoil::GetCoilMaxWaterFlowRate);
 
         // SUBROUTINE PARAMETER DEFINITIONS:
         constexpr std::array<std::string_view, static_cast<int>(VentilatedSlabConfig::Num)> VentilatedSlabConfigNamesUC{
@@ -251,17 +248,15 @@ namespace VentilatedSlab {
         Array1D_bool lNumericBlanks;   // Logical array, numeric field input BLANK = .TRUE.
         bool SteamMessageNeeded;
 
-        constexpr std::array<std::string_view, static_cast<int>(OutsideAirControlType::Num)> OutsideAirControlTypeNamesUC{
+        constexpr std::array<std::string_view, static_cast<int>(OutsideAirControlType::Num)> OutsideAirControlTypeNamesUC = {
             "VARIABLEPERCENT", "FIXEDTEMPERATURE", "FIXEDAMOUNT"};
-        constexpr std::array<std::string_view, static_cast<int>(CoilType::Num)> CoilTypeNamesUC{"NONE", "HEATING", "COOLING", "HEATINGANDCOOLING"};
-
-        constexpr std::array<std::string_view, static_cast<int>(HeatingCoilType::Num)> HeatingCoilTypeNamesUC{
-            "COIL:HEATING:ELECTRIC", "COIL:HEATING:FUEL", "COIL:HEATING:WATER", "COIL:HEATING:STEAM"};
-        constexpr std::array<std::string_view, static_cast<int>(CoolingCoilType::Num)> CoolingCoilTypeNamesUC{
-            "COIL:COOLING:WATER", "COIL:COOLING:WATER:DETAILEDGEOMETRY", "COILSYSTEM:COOLING:WATER:HEATEXCHANGERASSISTED"};
+        constexpr std::array<std::string_view, static_cast<int>(CoilOption::Num)> CoilOptionNamesUC = {
+            "NONE", "HEATING", "COOLING", "HEATINGANDCOOLING"};
 
         // Figure out how many Ventilated Slab Systems there are in the input file
 
+        auto &s_ipsc = state.dataIPShortCut;
+
         SteamMessageNeeded = true;
         state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, CurrentModuleObject, NumArgs, NumAlphas, NumNumbers);
         cAlphaArgs.allocate(NumAlphas);
@@ -287,9 +282,9 @@ namespace VentilatedSlab {
             state.dataInputProcessing->inputProcessor->getObjectItem(state,
                                                                      CurrentModuleObject,
                                                                      Item,
-                                                                     state.dataIPShortCut->cAlphaArgs,
+                                                                     s_ipsc->cAlphaArgs,
                                                                      NumAlphas,
-                                                                     state.dataIPShortCut->rNumericArgs,
+                                                                     s_ipsc->rNumericArgs,
                                                                      NumNumbers,
                                                                      IOStatus,
                                                                      lNumericBlanks,
@@ -297,22 +292,22 @@ namespace VentilatedSlab {
                                                                      cAlphaFields,
                                                                      cNumericFields);
 
-            ErrorObjectHeader eoh{routineName, CurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)};
+            ErrorObjectHeader eoh{routineName, CurrentModuleObject, s_ipsc->cAlphaArgs(1)};
 
             state.dataVentilatedSlab->VentSlabNumericFields(Item).FieldNames.allocate(NumNumbers);
             state.dataVentilatedSlab->VentSlabNumericFields(Item).FieldNames = cNumericFields;
-            Util::IsNameEmpty(state, state.dataIPShortCut->cAlphaArgs(1), CurrentModuleObject, ErrorsFound);
+            Util::IsNameEmpty(state, s_ipsc->cAlphaArgs(1), CurrentModuleObject, ErrorsFound);
             auto &ventSlab = state.dataVentilatedSlab->VentSlab(Item);
 
-            ventSlab.Name = state.dataIPShortCut->cAlphaArgs(1);
+            ventSlab.Name = s_ipsc->cAlphaArgs(1);
             if (lAlphaBlanks(2)) {
                 ventSlab.availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((ventSlab.availSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(2))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(2), state.dataIPShortCut->cAlphaArgs(2));
+            } else if ((ventSlab.availSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(2))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(2), s_ipsc->cAlphaArgs(2));
                 ErrorsFound = true;
             }
 
-            ventSlab.ZonePtr = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(3), state.dataHeatBal->Zone);
+            ventSlab.ZonePtr = Util::FindItemInList(s_ipsc->cAlphaArgs(3), state.dataHeatBal->Zone);
             if (ventSlab.ZonePtr == 0) {
                 if (lAlphaBlanks(3)) {
                     ShowSevereError(
@@ -323,12 +318,12 @@ namespace VentilatedSlab {
                                            CurrentModuleObject,
                                            ventSlab.Name,
                                            cAlphaFields(3),
-                                           state.dataIPShortCut->cAlphaArgs(3)));
+                                           s_ipsc->cAlphaArgs(3)));
                 }
                 ErrorsFound = true;
             }
 
-            ventSlab.SurfListName = state.dataIPShortCut->cAlphaArgs(4);
+            ventSlab.SurfListName = s_ipsc->cAlphaArgs(4);
             int SurfListNum = 0;
             //    IF (NumOfSlabLists > 0) SurfListNum = Util::FindItemInList(VentSlab(Item)%SurfListName, SlabList%Name, NumOfSlabLists)
             if (state.dataSurfLists->NumOfSurfListVentSlab > 0)
@@ -377,14 +372,14 @@ namespace VentilatedSlab {
                                            CurrentModuleObject,
                                            ventSlab.Name,
                                            cAlphaFields(4),
-                                           state.dataIPShortCut->cAlphaArgs(4)));
+                                           s_ipsc->cAlphaArgs(4)));
                     ErrorsFound = true;
                 } else if (state.dataSurface->SurfIsRadSurfOrVentSlabOrPool(ventSlab.SurfacePtr(1))) {
                     ShowSevereError(state, format("{}=\"{}\", invalid Surface", CurrentModuleObject, ventSlab.Name));
                     ShowContinueError(state,
                                       format("{}=\"{}\" has been used in another radiant system or ventilated slab.",
                                              cAlphaFields(4),
-                                             state.dataIPShortCut->cAlphaArgs(4)));
+                                             s_ipsc->cAlphaArgs(4)));
                     ErrorsFound = true;
                 }
                 if (ventSlab.SurfacePtr(1) != 0) {
@@ -432,7 +427,7 @@ namespace VentilatedSlab {
                                           format("Surface in Zone={} {} in Zone={}",
                                                  state.dataHeatBal->Zone(state.dataSurface->Surface(ventSlab.SurfacePtr(SurfNum)).Zone).Name,
                                                  CurrentModuleObject,
-                                                 state.dataIPShortCut->cAlphaArgs(3)));
+                                                 s_ipsc->cAlphaArgs(3)));
                         ErrorsFound = true;
                     }
                     if (state.dataSurface->Surface(ventSlab.SurfacePtr(SurfNum)).Construction == 0)
@@ -450,39 +445,39 @@ namespace VentilatedSlab {
                 }
             }
 
-            ventSlab.MaxAirVolFlow = state.dataIPShortCut->rNumericArgs(1);
+            ventSlab.MaxAirVolFlow = s_ipsc->rNumericArgs(1);
 
             // Outside air information:
-            ventSlab.MinOutAirVolFlow = state.dataIPShortCut->rNumericArgs(2);
-            ventSlab.OutAirVolFlow = state.dataIPShortCut->rNumericArgs(3);
+            ventSlab.MinOutAirVolFlow = s_ipsc->rNumericArgs(2);
+            ventSlab.OutAirVolFlow = s_ipsc->rNumericArgs(3);
 
             ventSlab.outsideAirControlType =
-                static_cast<OutsideAirControlType>(getEnumValue(OutsideAirControlTypeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(5))));
+                static_cast<OutsideAirControlType>(getEnumValue(OutsideAirControlTypeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(5))));
 
             switch (ventSlab.outsideAirControlType) {
 
             case OutsideAirControlType::VariablePercent: {
                 if (lAlphaBlanks(7)) {
-                    ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(7));
+                    ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(7));
                     ErrorsFound = true;
-                } else if ((ventSlab.maxOASched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(7))) == nullptr) {
-                    ShowSevereItemNotFound(state, eoh, cAlphaFields(7), state.dataIPShortCut->cAlphaArgs(7));
+                } else if ((ventSlab.maxOASched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(7))) == nullptr) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(7), s_ipsc->cAlphaArgs(7));
                     ErrorsFound = true;
                 } else if (!ventSlab.maxOASched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
-                    Sched::ShowSevereBadMinMax(state, eoh, cAlphaFields(7), state.dataIPShortCut->cAlphaArgs(7), Clusive::In, 0.0, Clusive::In, 1.0);
+                    Sched::ShowSevereBadMinMax(state, eoh, cAlphaFields(7), s_ipsc->cAlphaArgs(7), Clusive::In, 0.0, Clusive::In, 1.0);
                     ErrorsFound = true;
                 }
             } break;
 
             case OutsideAirControlType::FixedOAControl: {
                 if (lAlphaBlanks(7)) {
-                    ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(7));
+                    ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(7));
                     ErrorsFound = true;
-                } else if ((ventSlab.maxOASched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(7))) == nullptr) {
-                    ShowSevereItemNotFound(state, eoh, cAlphaFields(7), state.dataIPShortCut->cAlphaArgs(7));
+                } else if ((ventSlab.maxOASched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(7))) == nullptr) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(7), s_ipsc->cAlphaArgs(7));
                     ErrorsFound = true;
                 } else if (!ventSlab.maxOASched->checkMinVal(state, Clusive::In, 0.0)) {
-                    Sched::ShowSevereBadMin(state, eoh, cAlphaFields(7), state.dataIPShortCut->cAlphaArgs(7), Clusive::In, 0.0);
+                    Sched::ShowSevereBadMin(state, eoh, cAlphaFields(7), s_ipsc->cAlphaArgs(7), Clusive::In, 0.0);
                     ErrorsFound = true;
                 }
             } break;
@@ -491,8 +486,8 @@ namespace VentilatedSlab {
                 if (lAlphaBlanks(7)) {
                     ShowSevereEmptyField(state, eoh, cAlphaFields(7));
                     ErrorsFound = true;
-                } else if ((ventSlab.tempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(7))) == nullptr) {
-                    ShowSevereItemNotFound(state, eoh, cAlphaFields(7), state.dataIPShortCut->cAlphaArgs(7));
+                } else if ((ventSlab.tempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(7))) == nullptr) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(7), s_ipsc->cAlphaArgs(7));
                     ErrorsFound = true;
                 }
             } break;
@@ -500,29 +495,29 @@ namespace VentilatedSlab {
             default: {
                 ShowSevereError(
                     state,
-                    format(R"({}="{}" invalid {}="{}".)", CurrentModuleObject, ventSlab.Name, cAlphaFields(5), state.dataIPShortCut->cAlphaArgs(5)));
+                    format(R"({}="{}" invalid {}="{}".)", CurrentModuleObject, ventSlab.Name, cAlphaFields(5), s_ipsc->cAlphaArgs(5)));
             } break;
             } // switch (outsideAirControlType)
 
             if (lAlphaBlanks(6)) {
-            } else if ((ventSlab.minOASched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(6))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), state.dataIPShortCut->cAlphaArgs(6));
+            } else if ((ventSlab.minOASched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(6))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(6), s_ipsc->cAlphaArgs(6));
                 ErrorsFound = true;
             }
 
             // System Configuration:
-            ventSlab.SysConfg = static_cast<VentilatedSlabConfig>(getEnumValue(VentilatedSlabConfigNamesUC, state.dataIPShortCut->cAlphaArgs(8)));
+            ventSlab.SysConfg = static_cast<VentilatedSlabConfig>(getEnumValue(VentilatedSlabConfigNamesUC, s_ipsc->cAlphaArgs(8)));
             if (ventSlab.SysConfg == VentilatedSlabConfig::Invalid) {
-                ShowWarningInvalidKey(state, eoh, cAlphaFields(8), state.dataIPShortCut->cAlphaArgs(8), "Control reset to SLAB ONLY Configuration.");
+                ShowWarningInvalidKey(state, eoh, cAlphaFields(8), s_ipsc->cAlphaArgs(8), "Control reset to SLAB ONLY Configuration.");
                 ventSlab.SysConfg = VentilatedSlabConfig::SlabOnly;
             }
 
             // Hollow Core information :
-            ventSlab.CoreDiameter = state.dataIPShortCut->rNumericArgs(4);
-            ventSlab.CoreLength = state.dataIPShortCut->rNumericArgs(5);
-            ventSlab.CoreNumbers = state.dataIPShortCut->rNumericArgs(6);
+            ventSlab.CoreDiameter = s_ipsc->rNumericArgs(4);
+            ventSlab.CoreLength = s_ipsc->rNumericArgs(5);
+            ventSlab.CoreNumbers = s_ipsc->rNumericArgs(6);
 
-            if (Util::SameString(state.dataIPShortCut->cAlphaArgs(8), "SurfaceListNames")) {
+            if (Util::SameString(s_ipsc->cAlphaArgs(8), "SurfaceListNames")) {
                 if (!lNumericBlanks(4)) {
                     ShowWarningError(state,
                                      format("{}=\"{}\"  Core Diameter is not needed for the series slabs configuration- ignored.",
@@ -532,7 +527,7 @@ namespace VentilatedSlab {
                 }
             }
 
-            if (Util::SameString(state.dataIPShortCut->cAlphaArgs(8), "SurfaceListNames")) {
+            if (Util::SameString(s_ipsc->cAlphaArgs(8), "SurfaceListNames")) {
                 if (!lNumericBlanks(5)) {
                     ShowWarningError(state,
                                      format("{}=\"{}\"  Core Length is not needed for the series slabs configuration- ignored.",
@@ -542,7 +537,7 @@ namespace VentilatedSlab {
                 }
             }
 
-            if (Util::SameString(state.dataIPShortCut->cAlphaArgs(8), "SurfaceListNames")) {
+            if (Util::SameString(s_ipsc->cAlphaArgs(8), "SurfaceListNames")) {
                 if (!lNumericBlanks(6)) {
                     ShowWarningError(state,
                                      format("{}=\"{}\"  Core Numbers is not needed for the series slabs configuration- ignored.",
@@ -553,12 +548,12 @@ namespace VentilatedSlab {
             }
 
             // Process the temperature control type
-            ventSlab.controlType = static_cast<ControlType>(getEnumValue(ControlTypeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(9))));
+            ventSlab.controlType = static_cast<ControlType>(getEnumValue(ControlTypeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(9))));
 
             if (ventSlab.controlType == ControlType::Invalid) {
                 ShowSevereError(
                     state,
-                    format(R"({}="{}" invalid {}="{}".)", CurrentModuleObject, ventSlab.Name, cAlphaFields(9), state.dataIPShortCut->cAlphaArgs(9)));
+                    format(R"({}="{}" invalid {}="{}".)", CurrentModuleObject, ventSlab.Name, cAlphaFields(9), s_ipsc->cAlphaArgs(9)));
                 ShowContinueError(state, "Control reset to ODB control.");
                 ventSlab.controlType = ControlType::OutdoorDryBulbTemp;
             }
@@ -567,56 +562,56 @@ namespace VentilatedSlab {
 
             // High Air Temp :
             if (lAlphaBlanks(10)) {
-            } else if ((ventSlab.hotAirHiTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(10))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(10), state.dataIPShortCut->cAlphaArgs(10));
+            } else if ((ventSlab.hotAirHiTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(10))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(10), s_ipsc->cAlphaArgs(10));
                 ErrorsFound = true;
             }
 
             // Low Air Temp :
             if (lAlphaBlanks(11)) {
-            } else if ((ventSlab.hotAirLoTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(11))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(11), state.dataIPShortCut->cAlphaArgs(11));
+            } else if ((ventSlab.hotAirLoTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(11))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(11), s_ipsc->cAlphaArgs(11));
                 ErrorsFound = true;
             }
 
             if (lAlphaBlanks(12)) {
-            } else if ((ventSlab.hotCtrlHiTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(12))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(12), state.dataIPShortCut->cAlphaArgs(12));
+            } else if ((ventSlab.hotCtrlHiTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(12))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(12), s_ipsc->cAlphaArgs(12));
                 ErrorsFound = true;
             }
 
             if (lAlphaBlanks(13)) {
-            } else if ((ventSlab.hotCtrlLoTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(13))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(13), state.dataIPShortCut->cAlphaArgs(13));
+            } else if ((ventSlab.hotCtrlLoTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(13))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(13), s_ipsc->cAlphaArgs(13));
                 ErrorsFound = true;
             }
 
             // Cooling User Input Data For Ventilated Slab Control :
             // Cooling High Temp Sch.
             if (lAlphaBlanks(14)) {
-            } else if ((ventSlab.coldAirHiTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(14))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(14), state.dataIPShortCut->cAlphaArgs(14));
+            } else if ((ventSlab.coldAirHiTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(14))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(14), s_ipsc->cAlphaArgs(14));
                 ErrorsFound = true;
             }
 
             // Cooling Low Temp Sch.
             if (lAlphaBlanks(15)) {
-            } else if ((ventSlab.coldAirLoTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(15))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(15), state.dataIPShortCut->cAlphaArgs(15));
+            } else if ((ventSlab.coldAirLoTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(15))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(15), s_ipsc->cAlphaArgs(15));
                 ErrorsFound = true;
             }
 
             // Cooling Control High Sch.
             if (lAlphaBlanks(16)) {
-            } else if ((ventSlab.coldCtrlHiTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(16))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(16), state.dataIPShortCut->cAlphaArgs(16));
+            } else if ((ventSlab.coldCtrlHiTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(16))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(16), s_ipsc->cAlphaArgs(16));
                 ErrorsFound = true;
             }
 
             // Cooling Control Low Sch.
             if (lAlphaBlanks(17)) {
-            } else if ((ventSlab.coldCtrlLoTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(17))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, cAlphaFields(17), state.dataIPShortCut->cAlphaArgs(17));
+            } else if ((ventSlab.coldCtrlLoTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(17))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFields(17), s_ipsc->cAlphaArgs(17));
                 ErrorsFound = true;
             }
 
@@ -656,7 +651,7 @@ namespace VentilatedSlab {
             if (ventSlab.SysConfg == VentilatedSlabConfig::SlabOnly) {
 
                 ventSlab.ReturnAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(18),
+                                                                             s_ipsc->cAlphaArgs(18),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name + "-OA MIXER",
@@ -665,7 +660,7 @@ namespace VentilatedSlab {
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsNotParent);
                 ventSlab.ReturnAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(18),
+                                                                             s_ipsc->cAlphaArgs(18),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name,
@@ -674,7 +669,7 @@ namespace VentilatedSlab {
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsParent);
                 ventSlab.RadInNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                         state.dataIPShortCut->cAlphaArgs(19),
+                                                                         s_ipsc->cAlphaArgs(19),
                                                                          ErrorsFound,
                                                                          DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                          ventSlab.Name,
@@ -684,7 +679,7 @@ namespace VentilatedSlab {
                                                                          DataLoopNode::ObjectIsNotParent);
 
                 ventSlab.OAMixerOutNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                              state.dataIPShortCut->cAlphaArgs(23),
+                                                                              s_ipsc->cAlphaArgs(23),
                                                                               ErrorsFound,
                                                                               DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                               ventSlab.Name + "-OA MIXER",
@@ -693,7 +688,7 @@ namespace VentilatedSlab {
                                                                               NodeInputManager::CompFluidStream::Primary,
                                                                               DataLoopNode::ObjectIsNotParent);
                 ventSlab.FanOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(24),
+                                                                             s_ipsc->cAlphaArgs(24),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name,
@@ -705,7 +700,7 @@ namespace VentilatedSlab {
             } else if (ventSlab.SysConfg == VentilatedSlabConfig::SeriesSlabs) {
 
                 ventSlab.ReturnAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(18),
+                                                                             s_ipsc->cAlphaArgs(18),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name + "-OA MIXER",
@@ -714,7 +709,7 @@ namespace VentilatedSlab {
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsNotParent);
                 ventSlab.ReturnAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(18),
+                                                                             s_ipsc->cAlphaArgs(18),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name,
@@ -723,7 +718,7 @@ namespace VentilatedSlab {
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsParent);
                 ventSlab.RadInNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                         state.dataIPShortCut->cAlphaArgs(19),
+                                                                         s_ipsc->cAlphaArgs(19),
                                                                          ErrorsFound,
                                                                          DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                          ventSlab.Name,
@@ -733,7 +728,7 @@ namespace VentilatedSlab {
                                                                          DataLoopNode::ObjectIsNotParent);
 
                 ventSlab.OAMixerOutNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                              state.dataIPShortCut->cAlphaArgs(23),
+                                                                              s_ipsc->cAlphaArgs(23),
                                                                               ErrorsFound,
                                                                               DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                               ventSlab.Name + "-OA MIXER",
@@ -742,7 +737,7 @@ namespace VentilatedSlab {
                                                                               NodeInputManager::CompFluidStream::Primary,
                                                                               DataLoopNode::ObjectIsNotParent);
                 ventSlab.FanOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(24),
+                                                                             s_ipsc->cAlphaArgs(24),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name,
@@ -754,7 +749,7 @@ namespace VentilatedSlab {
             } else if (ventSlab.SysConfg == VentilatedSlabConfig::SlabAndZone) {
 
                 ventSlab.ReturnAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(18),
+                                                                             s_ipsc->cAlphaArgs(18),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name + "-SYSTEM",
@@ -763,7 +758,7 @@ namespace VentilatedSlab {
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsParent);
                 ventSlab.ReturnAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(18),
+                                                                             s_ipsc->cAlphaArgs(18),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name,
@@ -772,7 +767,7 @@ namespace VentilatedSlab {
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsParent);
                 ventSlab.ReturnAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(18),
+                                                                             s_ipsc->cAlphaArgs(18),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name + "-OA MIXER",
@@ -781,7 +776,7 @@ namespace VentilatedSlab {
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsNotParent);
                 ventSlab.RadInNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                         state.dataIPShortCut->cAlphaArgs(19),
+                                                                         s_ipsc->cAlphaArgs(19),
                                                                          ErrorsFound,
                                                                          DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                          ventSlab.Name,
@@ -790,7 +785,7 @@ namespace VentilatedSlab {
                                                                          NodeInputManager::CompFluidStream::Primary,
                                                                          DataLoopNode::ObjectIsNotParent);
                 ventSlab.OAMixerOutNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                              state.dataIPShortCut->cAlphaArgs(23),
+                                                                              s_ipsc->cAlphaArgs(23),
                                                                               ErrorsFound,
                                                                               DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                               ventSlab.Name + "-OA MIXER",
@@ -799,7 +794,7 @@ namespace VentilatedSlab {
                                                                               NodeInputManager::CompFluidStream::Primary,
                                                                               DataLoopNode::ObjectIsNotParent);
                 ventSlab.FanOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(24),
+                                                                             s_ipsc->cAlphaArgs(24),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name,
@@ -816,7 +811,7 @@ namespace VentilatedSlab {
                                             CurrentModuleObject,
                                             ventSlab.Name,
                                             cAlphaFields(20),
-                                            state.dataIPShortCut->cAlphaArgs(20)));
+                                            s_ipsc->cAlphaArgs(20)));
                     ShowContinueError(state, "It is used for \"SlabAndZone\" only");
                 }
 
@@ -828,7 +823,7 @@ namespace VentilatedSlab {
                 }
 
                 ventSlab.ZoneAirInNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(20),
+                                                                             s_ipsc->cAlphaArgs(20),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name + "-SYSTEM",
@@ -838,7 +833,7 @@ namespace VentilatedSlab {
                                                                              DataLoopNode::ObjectIsParent);
 
                 ventSlab.ZoneAirInNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             state.dataIPShortCut->cAlphaArgs(20),
+                                                                             s_ipsc->cAlphaArgs(20),
                                                                              ErrorsFound,
                                                                              DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                              ventSlab.Name,
@@ -850,7 +845,7 @@ namespace VentilatedSlab {
 
             //  Set connection type to 'Inlet', because it now uses an OA node
             ventSlab.OutsideAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                          state.dataIPShortCut->cAlphaArgs(21),
+                                                                          s_ipsc->cAlphaArgs(21),
                                                                           ErrorsFound,
                                                                           DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                           ventSlab.Name + "-OA MIXER",
@@ -864,12 +859,12 @@ namespace VentilatedSlab {
                 if (!IsValid) {
                     ShowWarningError(
                         state,
-                        format("{}=\"{}\", Adding OutdoorAir:Node={}", CurrentModuleObject, ventSlab.Name, state.dataIPShortCut->cAlphaArgs(21)));
+                        format("{}=\"{}\", Adding OutdoorAir:Node={}", CurrentModuleObject, ventSlab.Name, s_ipsc->cAlphaArgs(21)));
                 }
             }
 
             ventSlab.AirReliefNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                         state.dataIPShortCut->cAlphaArgs(22),
+                                                                         s_ipsc->cAlphaArgs(22),
                                                                          ErrorsFound,
                                                                          DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                          ventSlab.Name + "-OA MIXER",
@@ -879,10 +874,10 @@ namespace VentilatedSlab {
                                                                          DataLoopNode::ObjectIsNotParent);
 
             // Fan information:
-            ventSlab.FanName = state.dataIPShortCut->cAlphaArgs(25);
+            ventSlab.FanName = s_ipsc->cAlphaArgs(25);
 
             if ((ventSlab.Fan_Index = Fans::GetFanIndex(state, ventSlab.FanName)) == 0) {
-                ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(25), state.dataIPShortCut->cAlphaArgs(25));
+                ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(25), s_ipsc->cAlphaArgs(25));
                 ErrorsFound = true;
             } else {
                 ventSlab.fanType = state.dataFans->fans(ventSlab.Fan_Index)->type;
@@ -905,23 +900,20 @@ namespace VentilatedSlab {
                                                  CurrentModuleObject,
                                                  ventSlab.Name,
                                                  "UNDEFINED",
-                                                 state.dataIPShortCut->cAlphaArgs(25),
-                                                 state.dataIPShortCut->cAlphaArgs(23),
-                                                 state.dataIPShortCut->cAlphaArgs(24));
+                                                 s_ipsc->cAlphaArgs(25),
+                                                 s_ipsc->cAlphaArgs(23),
+                                                 s_ipsc->cAlphaArgs(24));
 
             // Coil options assign
 
-            ventSlab.coilOption = static_cast<CoilType>(getEnumValue(CoilTypeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(26))));
+            ventSlab.coilOption = static_cast<CoilOption>(getEnumValue(CoilOptionNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(26))));
 
-            if (ventSlab.coilOption == CoilType::Invalid) {
-                ShowSevereError(
-                    state,
-                    format(
-                        R"({}="{}" invalid {}="{}".)", CurrentModuleObject, ventSlab.Name, cAlphaFields(26), state.dataIPShortCut->cAlphaArgs(26)));
+            if (ventSlab.coilOption == CoilOption::Invalid) {
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(26), s_ipsc->cAlphaArgs(26));
                 ErrorsFound = true;
             }
 
-            if (ventSlab.coilOption == CoilType::Both || ventSlab.coilOption == CoilType::Heating) {
+            if (ventSlab.coilOption == CoilOption::Both || ventSlab.coilOption == CoilOption::Heating) {
                 // Heating coil information:
                 //        A27, \field Heating Coil Object Type
                 //             \type choice
@@ -934,74 +926,77 @@ namespace VentilatedSlab {
                 //             \object-list HeatingCoilName
 
                 // Heating coil information:
-                if (!lAlphaBlanks(28)) {
-                    ventSlab.heatingCoilPresent = true;
-                    ventSlab.heatingCoilTypeCh = state.dataIPShortCut->cAlphaArgs(27);
+                if (lAlphaBlanks(28)) {
+                    ShowSevereEmptyField(state, eoh, cAlphaFields(28), cAlphaFields(26), s_ipsc->cAlphaArgs(26));
+                    ErrorsFound = true;
+
+                } else {
+                    ventSlab.heatCoilPresent = true;
                     errFlag = false;
 
-                    ventSlab.hCoilType =
-                        static_cast<HeatingCoilType>(getEnumValue(HeatingCoilTypeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(27))));
+                    ventSlab.heatCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, s_ipsc->cAlphaArgs(27)));
+                    ventSlab.heatCoilName = s_ipsc->cAlphaArgs(28);
 
-                    switch (ventSlab.hCoilType) {
+                    switch (ventSlab.heatCoilType) {
 
-                    case HeatingCoilType::Water: {
-                        ventSlab.heatingCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-                        break;
-                    }
-                    case HeatingCoilType::Steam: {
-                        ventSlab.heatingCoilType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
-                        ventSlab.heatingCoil_fluid = Fluid::GetSteam(state);
-                        if (ventSlab.heatingCoil_fluid == nullptr) {
-                            ShowSevereError(state, format("{}=\"{}Steam Properties not found.", CurrentModuleObject, ventSlab.Name));
-                            if (SteamMessageNeeded) ShowContinueError(state, "Steam Fluid Properties should have been included in the input file.");
+                    case HVAC::CoilType::HeatingWater: {
+                        ventSlab.heatCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+                        // Why is a steam coil getting a fluidProps pointer and a water coil not getting one?
+                        ventSlab.heatCoilNum = WaterCoils::GetCoilIndex(state, ventSlab.heatCoilName);
+                        if (ventSlab.heatCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(28), s_ipsc->cAlphaArgs(28));
                             ErrorsFound = true;
-                            SteamMessageNeeded = false;
+                        } else {
+                            ventSlab.MaxVolHotWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, ventSlab.heatCoilNum);
+                            ventSlab.MaxVolHotSteamFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, ventSlab.heatCoilNum);
                         }
-                        break;
-                    }
-                    case HeatingCoilType::Electric:
-                    case HeatingCoilType::Gas:
-                        break;
-                    default: {
-                        ShowSevereError(state,
-                                        format(R"({}="{}" invalid {}="{}".)",
-                                               CurrentModuleObject,
-                                               ventSlab.Name,
-                                               cAlphaFields(27),
-                                               state.dataIPShortCut->cAlphaArgs(27)));
-                        ErrorsFound = true;
-                        errFlag = true;
-                        break;
-                    }
-                    }
-                    if (!errFlag) {
-                        ventSlab.heatingCoilName = state.dataIPShortCut->cAlphaArgs(28);
-                        ValidateComponent(state, state.dataIPShortCut->cAlphaArgs(27), ventSlab.heatingCoilName, IsNotOK, CurrentModuleObject);
-                        if (IsNotOK) {
-                            ShowContinueError(state,
-                                              format("{}=\"{}\" invalid {}=\"{}\".",
-                                                     CurrentModuleObject,
-                                                     ventSlab.Name,
-                                                     cAlphaFields(28),
-                                                     state.dataIPShortCut->cAlphaArgs(28)));
-                            ShowContinueError(state, format("... not valid for {}=\"{}\".", cAlphaFields(27), state.dataIPShortCut->cAlphaArgs(27)));
+                    } break;
+                    
+                    case HVAC::CoilType::HeatingSteam: {
+                        ventSlab.heatCoilPlantType = DataPlant::PlantEquipmentType::CoilSteamAirHeating;
+                        ventSlab.heatCoilFluid = Fluid::GetSteam(state);
+                        
+                        ventSlab.heatCoilNum = SteamCoils::GetCoilIndex(state, ventSlab.heatCoilName);
+                        if (ventSlab.heatCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(28), s_ipsc->cAlphaArgs(28));
+                            ErrorsFound = true;
+                        } else {
+                            ventSlab.MaxVolHotWaterFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, ventSlab.heatCoilNum);
+                            ventSlab.MaxVolHotSteamFlow = SteamCoils::GetCoilMaxSteamFlowRate(state, ventSlab.heatCoilNum);
+                        }
+                    } break;
+                    
+                    case HVAC::CoilType::HeatingElectric:
+                    case HVAC::CoilType::HeatingGasOrOtherFuel: {
+                        ventSlab.heatCoilNum = HeatingCoils::GetCoilIndex(state, ventSlab.heatCoilName);
+                        if (ventSlab.heatCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(28), s_ipsc->cAlphaArgs(28));
                             ErrorsFound = true;
+                        } else {
+                            ventSlab.MinVolHotWaterFlow = 0.0;
+                            ventSlab.MinVolHotSteamFlow = 0.0;
                         }
-                    }
+                    } break;
 
-                    ventSlab.MinVolHotWaterFlow = 0.0;
-                    ventSlab.MinVolHotSteamFlow = 0.0;
+                    default: {
+                        ShowSevereInvalidKey(state, eoh, cAlphaFields(27), s_ipsc->cAlphaArgs(27));
+                        ErrorsFound = true;
+                        errFlag = true;
+                    } break;
+                    } // switch ()
+                    
 
                     // The heating coil control node is necessary for a hot water coil, but not necessary for an
                     // electric or gas coil.
-                    if (ventSlab.hCoilType == HeatingCoilType::Gas || ventSlab.hCoilType == HeatingCoilType::Electric) {
+                    if (ventSlab.heatCoilType == HVAC::CoilType::HeatingGasOrOtherFuel ||
+                        ventSlab.heatCoilType == HVAC::CoilType::HeatingElectric) {
                         if (!lAlphaBlanks(29)) {
                             ShowWarningError(state,
                                              format("{}=\"{}\" {}=\"{}\" not needed - ignored.",
                                                     CurrentModuleObject,
                                                     ventSlab.Name,
                                                     cAlphaFields(29),
-                                                    state.dataIPShortCut->cAlphaArgs(29)));
+                                                    s_ipsc->cAlphaArgs(29)));
                             ShowContinueError(state, "..It is used for hot water coils only.");
                         }
                     } else {
@@ -1012,7 +1007,7 @@ namespace VentilatedSlab {
                             ErrorsFound = true;
                         }
                         ventSlab.HotControlNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                      state.dataIPShortCut->cAlphaArgs(29),
+                                                                                      s_ipsc->cAlphaArgs(29),
                                                                                       ErrorsFound,
                                                                                       DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                                       ventSlab.Name,
@@ -1022,24 +1017,10 @@ namespace VentilatedSlab {
                                                                                       DataLoopNode::ObjectIsParent);
                     }
                     ventSlab.HotControlOffset = 0.001;
-
-                    if (ventSlab.hCoilType == HeatingCoilType::Water) {
-                        ventSlab.MaxVolHotWaterFlow = GetWaterCoilMaxFlowRate(state, "Coil:Heating:Water", ventSlab.heatingCoilName, ErrorsFound);
-                        ventSlab.MaxVolHotSteamFlow = GetWaterCoilMaxFlowRate(state, "Coil:Heating:Water", ventSlab.heatingCoilName, ErrorsFound);
-                    } else if (ventSlab.hCoilType == HeatingCoilType::Steam) {
-                        ventSlab.MaxVolHotWaterFlow = GetSteamCoilMaxFlowRate(state, "Coil:Heating:Steam", ventSlab.heatingCoilName, ErrorsFound);
-                        ventSlab.MaxVolHotSteamFlow = GetSteamCoilMaxFlowRate(state, "Coil:Heating:Steam", ventSlab.heatingCoilName, ErrorsFound);
-                    }
-
-                } else { // no heating coil
-                    ShowSevereError(state, format("{}=\"{}\" missing heating coil.", CurrentModuleObject, ventSlab.Name));
-                    ShowContinueError(state,
-                                      format("a heating coil is required for {}=\"{}\".", cAlphaFields(26), state.dataIPShortCut->cAlphaArgs(26)));
-                    ErrorsFound = true;
                 }
             }
 
-            if (ventSlab.coilOption == CoilType::Both || ventSlab.coilOption == CoilType::Cooling) {
+            if (ventSlab.coilOption == CoilOption::Both || ventSlab.coilOption == CoilOption::Cooling) {
                 // Cooling coil information (if one is present):
                 //        A30, \field Cooling Coil Object Type
                 //             \type choice
@@ -1050,77 +1031,75 @@ namespace VentilatedSlab {
                 //             \type object-list
                 //             \object-list CoolingCoilsWater
                 // Cooling coil information (if one is present):
-                if (!lAlphaBlanks(31)) {
-                    ventSlab.coolingCoilPresent = true;
-                    ventSlab.coolingCoilTypeCh = state.dataIPShortCut->cAlphaArgs(30);
+                if (lAlphaBlanks(31)) {
+                    ShowSevereEmptyField(state, eoh, cAlphaFields(31), cAlphaFields(26), s_ipsc->cAlphaArgs(26));
+                    ErrorsFound = true;
+
+                } else { 
+                    ventSlab.coolCoilPresent = true;
+                    ventSlab.coolCoilName = s_ipsc->cAlphaArgs(31);
                     errFlag = false;
 
-                    ventSlab.cCoilType =
-                        static_cast<CoolingCoilType>(getEnumValue(CoolingCoilTypeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(30))));
-                    switch (ventSlab.cCoilType) {
-                    case CoolingCoilType::WaterCooling: {
-                        ventSlab.coolingCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                        ventSlab.coolingCoilPlantName = state.dataIPShortCut->cAlphaArgs(31);
-                        break;
-                    }
-                    case CoolingCoilType::DetailedCooling: {
-                        ventSlab.coolingCoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
-                        ventSlab.coolingCoilPlantName = state.dataIPShortCut->cAlphaArgs(31);
-                        break;
-                    }
-                    case CoolingCoilType::HXAssisted: {
-                        HVACHXAssistedCoolingCoil::GetHXCoilTypeAndName(state,
-                                                                        state.dataIPShortCut->cAlphaArgs(30),
-                                                                        state.dataIPShortCut->cAlphaArgs(31),
-                                                                        ErrorsFound,
-                                                                        ventSlab.coolingCoilPlantType,
-                                                                        ventSlab.coolingCoilPlantName);
-                        if (Util::SameString(ventSlab.coolingCoilPlantType, "Coil:Cooling:Water")) {
-                            ventSlab.coolingCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-                        } else if (Util::SameString(ventSlab.coolingCoilPlantType, "Coil:Cooling:Water:DetailedGeometry")) {
-                            ventSlab.coolingCoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+                    ventSlab.coolCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, s_ipsc->cAlphaArgs(30)));
+                    switch (ventSlab.coolCoilType) {
+                    case HVAC::CoilType::CoolingWater: {
+                        ventSlab.coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+                        ventSlab.coolCoilNum = WaterCoils::GetCoilIndex(state, ventSlab.coolCoilName);
+                        if (ventSlab.coolCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(31), s_ipsc->cAlphaArgs(31));
+                            ErrorsFound = true;
                         } else {
-                            ShowSevereError(state, format("GetVentilatedSlabInput: {}=\"{}\", invalid", CurrentModuleObject, ventSlab.Name));
-                            ShowContinueError(state, format("For: {}=\"{}\".", cAlphaFields(30), state.dataIPShortCut->cAlphaArgs(30)));
-                            ShowContinueError(state,
-                                              format("Invalid Coil Type={}, Name={}", ventSlab.coolingCoilPlantType, ventSlab.coolingCoilPlantName));
-                            ShowContinueError(state, R"(must be "Coil:Cooling:Water" or "Coil:Cooling:Water:DetailedGeometry")");
+                            ventSlab.MaxVolColdWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, ventSlab.coolCoilNum);
+                        }
+                    } break;
+                      
+                    case HVAC::CoilType::CoolingWaterDetailed: {
+                        ventSlab.coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+                        ventSlab.coolCoilNum = WaterCoils::GetCoilIndex(state, ventSlab.coolCoilName);
+                        if (ventSlab.coolCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(31), s_ipsc->cAlphaArgs(31));
                             ErrorsFound = true;
+                        } else {
+                            ventSlab.MaxVolColdWaterFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, ventSlab.coolCoilNum);
                         }
-                        break;
-                    }
+                    } break;
+                      
+                    case HVAC::CoilType::CoolingWaterHXAssisted: {
+                        ventSlab.coolCoilNum = HXAssistCoil::GetCoilIndex(state, ventSlab.coolCoilName);
+                        if (ventSlab.coolCoilNum == 0) {
+                            ShowSevereItemNotFound(state, eoh, cAlphaFields(31), s_ipsc->cAlphaArgs(31));
+                            ErrorsFound = true;
+                        } else {
+                            ventSlab.childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(state, ventSlab.coolCoilNum);
+                            ventSlab.childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(state, ventSlab.coolCoilNum);
+                            if (ventSlab.childCoolCoilType == HVAC::CoilType::CoolingWater) { 
+                                ventSlab.coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+                            } else if (ventSlab.childCoolCoilType == HVAC::CoilType::CoolingWaterDetailed) { 
+                                ventSlab.coolCoilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+                            } else {
+                                ShowSevereError(state, format("GetVentilatedSlabInput: {}=\"{}\", invalid", CurrentModuleObject, ventSlab.Name));
+                                ShowContinueError(state, format("For: {}=\"{}\".", cAlphaFields(31), s_ipsc->cAlphaArgs(31)));
+                                ShowContinueError(state,
+                                                  format("Invalid Coil Type={}, Name={}", HVAC::coilTypeNames[(int)ventSlab.childCoolCoilType], ventSlab.childCoolCoilName));
+                                ShowContinueError(state, R"(must be "Coil:Cooling:Water" or "Coil:Cooling:Water:DetailedGeometry")");
+                                ErrorsFound = true;
+                            }
+                            ventSlab.childCoolCoilNum =  HXAssistCoil::GetCoilChildCoilIndex(state, ventSlab.coolCoilNum);
+                            ventSlab.MaxVolColdWaterFlow = HXAssistCoil::GetCoilMaxWaterFlowRate(state, ventSlab.coolCoilNum);
+                        }
+                    } break;
+                        
                     default: {
-                        ShowSevereError(state,
-                                        format(R"({}="{}" invalid {}="{}".)",
-                                               CurrentModuleObject,
-                                               ventSlab.Name,
-                                               cAlphaFields(29),
-                                               state.dataIPShortCut->cAlphaArgs(29)));
+                        ShowSevereInvalidKey(state, eoh, cAlphaFields(29), s_ipsc->cAlphaArgs(29));
                         ErrorsFound = true;
                         errFlag = true;
-                        break;
-                    }
-                    }
-
-                    if (!errFlag) {
-                        ventSlab.coolingCoilName = state.dataIPShortCut->cAlphaArgs(31);
-                        ValidateComponent(state, state.dataIPShortCut->cAlphaArgs(30), ventSlab.coolingCoilName, IsNotOK, "ZoneHVAC:VentilatedSlab ");
-                        if (IsNotOK) {
-                            ShowContinueError(state,
-                                              format("{}=\"{}\" invalid {}=\"{}\".",
-                                                     CurrentModuleObject,
-                                                     ventSlab.Name,
-                                                     cAlphaFields(31),
-                                                     state.dataIPShortCut->cAlphaArgs(31)));
-                            ShowContinueError(state, format("... not valid for {}=\"{}\".", cAlphaFields(30), state.dataIPShortCut->cAlphaArgs(30)));
-                            ErrorsFound = true;
-                        }
-                    }
+                    } break;
+                    } // switch ()
 
                     ventSlab.MinVolColdWaterFlow = 0.0;
 
                     ventSlab.ColdControlNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                   state.dataIPShortCut->cAlphaArgs(32),
+                                                                                   s_ipsc->cAlphaArgs(32),
                                                                                    ErrorsFound,
                                                                                    DataLoopNode::ConnectionObjectType::ZoneHVACVentilatedSlab,
                                                                                    ventSlab.Name,
@@ -1130,86 +1109,70 @@ namespace VentilatedSlab {
                                                                                    DataLoopNode::ObjectIsParent);
 
                     if (lAlphaBlanks(32)) {
-                        ShowSevereError(
-                            state,
-                            format("{}=\"{}\" invalid {} is blank and must be entered.", CurrentModuleObject, ventSlab.Name, cAlphaFields(32)));
+                        ShowSevereEmptyField(state, eoh, cAlphaFields(32));
                         ErrorsFound = true;
                     }
 
                     ventSlab.ColdControlOffset = 0.001;
 
-                    if (ventSlab.cCoilType == CoolingCoilType::WaterCooling) {
-                        ventSlab.MaxVolColdWaterFlow = GetWaterCoilMaxFlowRate(state, "Coil:Cooling:Water", ventSlab.coolingCoilName, ErrorsFound);
-                    } else if (ventSlab.cCoilType == CoolingCoilType::DetailedCooling) {
-                        ventSlab.MaxVolColdWaterFlow =
-                            GetWaterCoilMaxFlowRate(state, "Coil:Cooling:Water:DetailedGeometry", ventSlab.coolingCoilName, ErrorsFound);
-                    } else if (ventSlab.cCoilType == CoolingCoilType::HXAssisted) {
-                        ventSlab.MaxVolColdWaterFlow =
-                            GetHXAssistedCoilFlowRate(state, "CoilSystem:Cooling:Water:HeatExchangerAssisted", ventSlab.coolingCoilName, ErrorsFound);
-                    }
 
-                } else { // No Cooling Coil
-                    ShowSevereError(state, format("{}=\"{}\" missing cooling coil.", CurrentModuleObject, ventSlab.Name));
-                    ShowContinueError(state,
-                                      format("a cooling coil is required for {}=\"{}\".", cAlphaFields(26), state.dataIPShortCut->cAlphaArgs(26)));
-                    ErrorsFound = true;
                 }
             }
 
             ventSlab.HVACSizingIndex = 0;
             if (!lAlphaBlanks(34)) {
-                ventSlab.HVACSizingIndex = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(34), state.dataSize->ZoneHVACSizing);
+                ventSlab.HVACSizingIndex = Util::FindItemInList(s_ipsc->cAlphaArgs(34), state.dataSize->ZoneHVACSizing);
                 if (ventSlab.HVACSizingIndex == 0) {
-                    ShowSevereError(state, format("{} = {} not found.", cAlphaFields(34), state.dataIPShortCut->cAlphaArgs(34)));
+                    ShowSevereError(state, format("{} = {} not found.", cAlphaFields(34), s_ipsc->cAlphaArgs(34)));
                     ShowContinueError(state, format("Occurs in {} = {}", cMO_VentilatedSlab, ventSlab.Name));
                     ErrorsFound = true;
                 }
             }
 
             switch (ventSlab.coilOption) {
-            case CoilType::Both: { // 'HeatingAndCooling'
+            case CoilOption::Both: { // 'HeatingAndCooling'
                 // Add cooling coil to component sets array when present
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      ventSlab.Name,
-                                                     state.dataIPShortCut->cAlphaArgs(30),
-                                                     state.dataIPShortCut->cAlphaArgs(31),
-                                                     state.dataIPShortCut->cAlphaArgs(24),
+                                                     s_ipsc->cAlphaArgs(30),
+                                                     s_ipsc->cAlphaArgs(31),
+                                                     s_ipsc->cAlphaArgs(24),
                                                      "UNDEFINED");
 
                 // Add heating coil to component sets array when cooling coil present
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      ventSlab.Name,
-                                                     state.dataIPShortCut->cAlphaArgs(27),
-                                                     state.dataIPShortCut->cAlphaArgs(28),
+                                                     s_ipsc->cAlphaArgs(27),
+                                                     s_ipsc->cAlphaArgs(28),
                                                      "UNDEFINED",
-                                                     state.dataIPShortCut->cAlphaArgs(19));
-                break;
-            }
-            case CoilType::Heating: { // 'Heating'
+                                                     s_ipsc->cAlphaArgs(19));
+            } break;
+              
+            case CoilOption::Heating: { // 'Heating'
                 // Add heating coil to component sets array when no cooling coil present
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      ventSlab.Name,
-                                                     state.dataIPShortCut->cAlphaArgs(27),
-                                                     state.dataIPShortCut->cAlphaArgs(28),
-                                                     state.dataIPShortCut->cAlphaArgs(24),
-                                                     state.dataIPShortCut->cAlphaArgs(19));
-                break;
-            }
-            case CoilType::Cooling: { // 'Cooling'
+                                                     s_ipsc->cAlphaArgs(27),
+                                                     s_ipsc->cAlphaArgs(28),
+                                                     s_ipsc->cAlphaArgs(24),
+                                                     s_ipsc->cAlphaArgs(19));
+            } break;
+              
+            case CoilOption::Cooling: { // 'Cooling'
                 // Add cooling coil to component sets array when no heating coil present
                 BranchNodeConnections::SetUpCompSets(state,
                                                      CurrentModuleObject,
                                                      ventSlab.Name,
-                                                     state.dataIPShortCut->cAlphaArgs(30),
-                                                     state.dataIPShortCut->cAlphaArgs(31),
-                                                     state.dataIPShortCut->cAlphaArgs(24),
-                                                     state.dataIPShortCut->cAlphaArgs(19));
-                break;
-            }
-            case CoilType::None:
+                                                     s_ipsc->cAlphaArgs(30),
+                                                     s_ipsc->cAlphaArgs(31),
+                                                     s_ipsc->cAlphaArgs(24),
+                                                     s_ipsc->cAlphaArgs(19));
+            } break;
+
+            case CoilOption::None:
             default:
                 break;
             }
@@ -1449,11 +1412,10 @@ namespace VentilatedSlab {
         }
 
         if (state.dataVentilatedSlab->MyPlantScanFlag(Item) && allocated(state.dataPlnt->PlantLoop)) {
-            if ((ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) ||
-                (ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilSteamAirHeating)) {
+            if (ventSlab.heatCoilType == HVAC::CoilType::HeatingWater ||
+                ventSlab.heatCoilType == HVAC::CoilType::HeatingSteam) {
                 bool errFlag = false;
-                PlantUtilities::ScanPlantLoopsForObject(
-                    state, ventSlab.heatingCoilName, ventSlab.heatingCoilType, ventSlab.HWPlantLoc, errFlag, _, _, _, _, _);
+                PlantUtilities::ScanPlantLoopsForObject(state, ventSlab.heatCoilName, ventSlab.heatCoilPlantType, ventSlab.HWPlantLoc, errFlag);
                 if (errFlag) {
                     ShowContinueError(state, format("Reference Unit=\"{}\", type=ZoneHVAC:VentilatedSlab", ventSlab.Name));
                     ShowFatalError(state, "InitVentilatedSlab: Program terminated due to previous condition(s).");
@@ -1461,18 +1423,28 @@ namespace VentilatedSlab {
 
                 ventSlab.HotCoilOutNodeNum = DataPlant::CompData::getPlantComponent(state, ventSlab.HWPlantLoc).NodeNumOut;
             }
-            if ((ventSlab.coolingCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
-                (ventSlab.coolingCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) {
+            
+            if (ventSlab.coolCoilType == HVAC::CoilType::CoolingWater || 
+                ventSlab.coolCoilType == HVAC::CoilType::CoolingWaterDetailed) {
                 bool errFlag = false;
-                PlantUtilities::ScanPlantLoopsForObject(state, ventSlab.coolingCoilPlantName, ventSlab.coolingCoilType, ventSlab.CWPlantLoc, errFlag);
+                PlantUtilities::ScanPlantLoopsForObject(state, ventSlab.coolCoilName, ventSlab.coolCoilPlantType, ventSlab.CWPlantLoc, errFlag);
                 if (errFlag) {
                     ShowContinueError(state, format("Reference Unit=\"{}\", type=ZoneHVAC:VentilatedSlab", ventSlab.Name));
                     ShowFatalError(state, "InitVentilatedSlab: Program terminated due to previous condition(s).");
                 }
                 ventSlab.ColdCoilOutNodeNum = DataPlant::CompData::getPlantComponent(state, ventSlab.CWPlantLoc).NodeNumOut;
-            } else {
-                if (ventSlab.coolingCoilPresent)
-                    ShowFatalError(state, format("InitVentilatedSlab: Unit={}, invalid cooling coil type. Program terminated.", ventSlab.Name));
+
+            } else if (ventSlab.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) { 
+                bool errFlag = false;
+                PlantUtilities::ScanPlantLoopsForObject(state, ventSlab.childCoolCoilName, ventSlab.coolCoilPlantType, ventSlab.CWPlantLoc, errFlag);
+                if (errFlag) {
+                    ShowContinueError(state, format("Reference Unit=\"{}\", type=ZoneHVAC:VentilatedSlab", ventSlab.Name));
+                    ShowFatalError(state, "InitVentilatedSlab: Program terminated due to previous condition(s).");
+                }
+                ventSlab.ColdCoilOutNodeNum = DataPlant::CompData::getPlantComponent(state, ventSlab.CWPlantLoc).NodeNumOut;
+                
+            } else if (ventSlab.coolCoilPresent) {
+                ShowFatalError(state, format("InitVentilatedSlab: Unit={}, invalid cooling coil type. Program terminated.", ventSlab.Name));
             }
             state.dataVentilatedSlab->MyPlantScanFlag(Item) = false;
         } else if (state.dataVentilatedSlab->MyPlantScanFlag(Item) && !state.dataGlobal->AnyPlantInModel) {
@@ -1546,9 +1518,9 @@ namespace VentilatedSlab {
             state.dataLoopNodes->Node(InNode).MassFlowRateMax = ventSlab.MaxAirMassFlow;
             state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
 
-            if (ventSlab.heatingCoilPresent) { // Only initialize these if a heating coil is actually present
+            if (ventSlab.heatCoilPresent) { // Only initialize these if a heating coil is actually present
 
-                if (ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating &&
+                if (ventSlab.heatCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating &&
                     !state.dataVentilatedSlab->MyPlantScanFlag(Item)) {
                     rho = state.dataPlnt->PlantLoop(ventSlab.HWPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName);
 
@@ -1557,11 +1529,10 @@ namespace VentilatedSlab {
 
                     PlantUtilities::InitComponentNodes(
                         state, ventSlab.MinHotWaterFlow, ventSlab.MaxHotWaterFlow, ventSlab.HotControlNode, ventSlab.HotCoilOutNodeNum);
-                }
-                if (ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilSteamAirHeating &&
+
+                } else if (ventSlab.heatCoilPlantType == DataPlant::PlantEquipmentType::CoilSteamAirHeating &&
                     !state.dataVentilatedSlab->MyPlantScanFlag(Item)) {
-                    TempSteamIn = 100.00;
-                    SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, TempSteamIn, 1.0, RoutineName);
+                    Real64 SteamDensity = Fluid::GetSteam(state)->getSatDensity(state, 100.0, 1.0, RoutineName);
                     ventSlab.MaxHotSteamFlow = SteamDensity * ventSlab.MaxVolHotSteamFlow;
                     ventSlab.MinHotSteamFlow = SteamDensity * ventSlab.MinVolHotSteamFlow;
 
@@ -1570,11 +1541,11 @@ namespace VentilatedSlab {
                 }
             } //(VentSlab(Item)%HCoilPresent)
 
-            if (ventSlab.coolingCoilPresent && !state.dataVentilatedSlab->MyPlantScanFlag(Item)) {
+            if (ventSlab.coolCoilPresent && !state.dataVentilatedSlab->MyPlantScanFlag(Item)) {
                 // Only initialize these if a cooling coil is actually present
-                if ((ventSlab.coolingCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
-                    (ventSlab.coolingCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) {
-                    rho = state.dataPlnt->PlantLoop(ventSlab.CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName);
+                if ((ventSlab.coolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
+                    (ventSlab.coolCoilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) {
+                    Real64 rho = state.dataPlnt->PlantLoop(ventSlab.CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName);
                     ventSlab.MaxColdWaterFlow = rho * ventSlab.MaxVolColdWaterFlow;
                     ventSlab.MinColdWaterFlow = rho * ventSlab.MinVolColdWaterFlow;
                     PlantUtilities::InitComponentNodes(
@@ -1951,7 +1922,8 @@ namespace VentilatedSlab {
         if (ventSlab.MaxVolHotWaterFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
-        if (ventSlab.hCoilType == HeatingCoilType::Water) {
+        
+        if (ventSlab.heatCoilType == HVAC::CoilType::HeatingWater) {
 
             if (CurZoneEqNum > 0) {
                 if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) {
@@ -1962,14 +1934,13 @@ namespace VentilatedSlab {
                 } else { // Autosize or hard-size with sizing run
                     CheckZoneSizing(state, cMO_VentilatedSlab, ventSlab.Name);
 
-                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", ventSlab.heatingCoilName, ErrorsFound);
-                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, "Coil:Heating:Water", ventSlab.heatingCoilName, ErrorsFound);
+                    int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, ventSlab.heatCoilNum);
+                    int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, ventSlab.heatCoilNum);
                     if (IsAutoSize) {
                         int PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(
-                            state, "Coil:Heating:Water", ventSlab.heatingCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound);
-                        int CoilNum = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", ventSlab.heatingCoilName, ErrorsFound);
-                        if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) {
-                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp;
+                            state, "Coil:Heating:Water", ventSlab.heatCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound);
+                        if (state.dataWaterCoils->WaterCoil(ventSlab.heatCoilNum).UseDesignWaterDeltaTemp) {
+                            WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(ventSlab.heatCoilNum).DesignWaterDeltaTemp;
                             DoWaterCoilSizing = true;
                         } else {
                             if (PltSizHeatNum > 0) {
@@ -2079,7 +2050,8 @@ namespace VentilatedSlab {
         if (ventSlab.MaxVolHotSteamFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
-        if (ventSlab.hCoilType == HeatingCoilType::Steam) {
+        
+        if (ventSlab.heatCoilType == HVAC::CoilType::HeatingSteam) {
 
             if (CurZoneEqNum > 0) {
                 if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) {
@@ -2090,11 +2062,11 @@ namespace VentilatedSlab {
                 } else { // Autosize or hard-size with sizing run
                     CheckZoneSizing(state, "ZoneHVAC:VentilatedSlab", ventSlab.Name);
 
-                    int CoilSteamInletNode = SteamCoils::GetCoilSteamInletNode(state, "Coil:Heating:Steam", ventSlab.heatingCoilName, ErrorsFound);
-                    int CoilSteamOutletNode = SteamCoils::GetCoilSteamOutletNode(state, "Coil:Heating:Steam", ventSlab.heatingCoilName, ErrorsFound);
+                    int CoilSteamInletNode = SteamCoils::GetCoilSteamInletNode(state, ventSlab.heatCoilNum);
+                    int CoilSteamOutletNode = SteamCoils::GetCoilSteamOutletNode(state, ventSlab.heatCoilNum);
                     if (IsAutoSize) {
                         int PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(
-                            state, "Coil:Heating:Steam", ventSlab.heatingCoilName, CoilSteamInletNode, CoilSteamOutletNode, ErrorsFound);
+                            state, "Coil:Heating:Steam", ventSlab.heatCoilName, CoilSteamInletNode, CoilSteamOutletNode, ErrorsFound);
                         if (PltSizHeatNum > 0) {
                             if (state.dataSize->FinalZoneSizing(CurZoneEqNum).DesHeatMassFlow >= HVAC::SmallAirVolFlow) {
                                 SizingMethod = HVAC::HeatingCapacitySizing;
@@ -2202,6 +2174,7 @@ namespace VentilatedSlab {
         if (ventSlab.MaxVolColdWaterFlow == DataSizing::AutoSize) {
             IsAutoSize = true;
         }
+        
         if (CurZoneEqNum > 0) {
             if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) {
                 if (ventSlab.MaxVolColdWaterFlow > 0.0) {
@@ -2210,23 +2183,20 @@ namespace VentilatedSlab {
                 }
             } else {
                 CheckZoneSizing(state, cMO_VentilatedSlab, ventSlab.Name);
-                if (ventSlab.cCoilType == CoolingCoilType::HXAssisted) {
-                    CoolingCoilName =
-                        HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, ventSlab.coolingCoilTypeCh, ventSlab.coolingCoilName, ErrorsFound);
-                    CoolingCoilType =
-                        HVACHXAssistedCoolingCoil::GetHXCoilType(state, ventSlab.coolingCoilTypeCh, ventSlab.coolingCoilName, ErrorsFound);
-                } else {
-                    CoolingCoilName = ventSlab.coolingCoilName;
-                    CoolingCoilType = ventSlab.coolingCoilTypeCh;
-                }
-                int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
-                int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
+                int waterCoilNum = (ventSlab.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) ?
+                    ventSlab.childCoolCoilNum : ventSlab.coolCoilNum;
+                std::string waterCoilName = (ventSlab.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) ?
+                  ventSlab.childCoolCoilName : ventSlab.coolCoilName;
+                HVAC::CoilType waterCoilType = (ventSlab.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) ?
+                  ventSlab.childCoolCoilType : ventSlab.coolCoilType;
+                
+                int CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, waterCoilNum);
+                int CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, waterCoilNum);
                 if (IsAutoSize) {
                     int PltSizCoolNum = PlantUtilities::MyPlantSizingIndex(
-                        state, CoolingCoilType, CoolingCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound);
-                    int CoilNum = WaterCoils::GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound);
-                    if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) {
-                        WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp;
+                        state, HVAC::coilTypeNames[(int)waterCoilType], waterCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound);
+                    if (state.dataWaterCoils->WaterCoil(waterCoilNum).UseDesignWaterDeltaTemp) {
+                        WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(waterCoilNum).DesignWaterDeltaTemp;
                         DoWaterCoilSizing = true;
                     } else {
                         if (PltSizCoolNum > 0) {
@@ -2326,15 +2296,13 @@ namespace VentilatedSlab {
             }
         }
 
-        if (ventSlab.cCoilType == CoolingCoilType::HXAssisted) {
-            CoolingCoilName = HVACHXAssistedCoolingCoil::GetHXDXCoilName(state, ventSlab.coolingCoilTypeCh, ventSlab.coolingCoilName, ErrorsFound);
-            CoolingCoilType = HVACHXAssistedCoolingCoil::GetHXCoilType(state, ventSlab.coolingCoilTypeCh, ventSlab.coolingCoilName, ErrorsFound);
-        } else {
-            CoolingCoilName = ventSlab.coolingCoilName;
-            CoolingCoilType = ventSlab.coolingCoilTypeCh;
+        if (ventSlab.coolCoilPresent) {
+            int coolCoilNum = (ventSlab.coolCoilType == HVAC::CoilType::CoolingDXHXAssisted) ? ventSlab.childCoolCoilNum : ventSlab.coolCoilNum;
+            WaterCoils::SetCoilDesFlow(state, coolCoilNum, ventSlab.MaxAirVolFlow);
+        }
+        if (ventSlab.heatCoilPresent) {
+            WaterCoils::SetCoilDesFlow(state, ventSlab.heatCoilNum, ventSlab.MaxAirVolFlow);
         }
-        WaterCoils::SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, ventSlab.MaxAirVolFlow, ErrorsFound);
-        WaterCoils::SetCoilDesFlow(state, ventSlab.heatingCoilTypeCh, ventSlab.heatingCoilName, ventSlab.MaxAirVolFlow, ErrorsFound);
 
         if (CurZoneEqNum > 0) {
             auto &zoneEqSizing = state.dataSize->ZoneEqSizing(CurZoneEqNum);
@@ -2443,102 +2411,37 @@ namespace VentilatedSlab {
         int RadSurfNum;        // DO loop counter for the surfaces that comprise a particular radiant system
         static std::string const CurrentModuleObject("ZoneHVAC:VentilatedSlab");
 
-        switch (ventSlab.coilOption) {
-        case CoilType::Both: {
-
-            switch (ventSlab.hCoilType) {
-            case HeatingCoilType::Water: {
-                WaterCoils::CheckWaterCoilSchedule(state, ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            case HeatingCoilType::Steam: {
-                SteamCoils::CheckSteamCoilSchedule(
-                    state, "Coil:Heating:Steam", ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            case HeatingCoilType::Electric: {
-                HeatingCoils::CheckHeatingCoilSchedule(
-                    state, "Coil:Heating:Electric", ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            case HeatingCoilType::Gas: {
-                HeatingCoils::CheckHeatingCoilSchedule(
-                    state, "Coil:Heating:Fuel", ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            default:
-                break;
-            }
+        if (ventSlab.coilOption == CoilOption::Both || ventSlab.coilOption == CoilOption::Heating) {
 
-            switch (ventSlab.cCoilType) {
-            case CoolingCoilType::WaterCooling:
-            case CoolingCoilType::DetailedCooling: {
-                WaterCoils::CheckWaterCoilSchedule(state, ventSlab.coolingCoilName, ventSlab.coolingCoilSchedValue, ventSlab.coolingCoil_Index);
-                break;
-            }
-            case CoolingCoilType::HXAssisted: {
-                HVACHXAssistedCoolingCoil::CheckHXAssistedCoolingCoilSchedule(state,
-                                                                              "CoilSystem:Cooling:Water:HeatExchangerAssisted",
-                                                                              ventSlab.coolingCoilName,
-                                                                              ventSlab.coolingCoilSchedValue,
-                                                                              ventSlab.coolingCoil_Index);
-                break;
-            }
-            default:
-                break;
+            switch (ventSlab.heatCoilType) {
+            case HVAC::CoilType::HeatingWater: {
+                ventSlab.heatCoilSchedVal = WaterCoils::GetCoilScheduleValue(state, ventSlab.heatCoilNum);
+            } break;
+            case HVAC::CoilType::HeatingSteam: {
+                ventSlab.heatCoilSchedVal = SteamCoils::GetCoilScheduleValue(state, ventSlab.heatCoilNum);
+            } break;
+            case HVAC::CoilType::HeatingElectric: 
+            case HVAC::CoilType::HeatingGasOrOtherFuel: {
+                ventSlab.heatCoilSchedVal = HeatingCoils::GetCoilScheduleValue(state, ventSlab.heatCoilNum);
+            } break;
+            default: {
+            } break;
             }
-            break;
         }
-        case CoilType::Heating: {
 
-            switch (ventSlab.hCoilType) {
-            case HeatingCoilType::Water: {
-                WaterCoils::CheckWaterCoilSchedule(state, ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            case HeatingCoilType::Steam: {
-                SteamCoils::CheckSteamCoilSchedule(
-                    state, "Coil:Heating:Steam", ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            case HeatingCoilType::Electric: {
-                HeatingCoils::CheckHeatingCoilSchedule(
-                    state, "Coil:Heating:Electric", ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            case HeatingCoilType::Gas: {
-                HeatingCoils::CheckHeatingCoilSchedule(
-                    state, "Coil:Heating:Fuel", ventSlab.heatingCoilName, ventSlab.heatingCoilSchedValue, ventSlab.heatingCoil_Index);
-                break;
-            }
-            default:
-                break;
-            }
-            break;
-        }
-        case CoilType::Cooling: {
+        if (ventSlab.coilOption == CoilOption::Both || ventSlab.coilOption == CoilOption::Cooling) { 
+            switch (ventSlab.coolCoilType) {
+            case HVAC::CoilType::CoolingWater:
+            case HVAC::CoilType::CoolingWaterDetailed: {
+                ventSlab.coolCoilSchedVal = WaterCoils::GetCoilScheduleValue(state, ventSlab.coolCoilNum);
+            } break;
 
-            switch (ventSlab.cCoilType) {
-            case CoolingCoilType::WaterCooling:
-            case CoolingCoilType::DetailedCooling: {
-                WaterCoils::CheckWaterCoilSchedule(state, ventSlab.coolingCoilName, ventSlab.coolingCoilSchedValue, ventSlab.coolingCoil_Index);
-                break;
-            }
-            case CoolingCoilType::HXAssisted: {
-                HVACHXAssistedCoolingCoil::CheckHXAssistedCoolingCoilSchedule(state,
-                                                                              "CoilSystem:Cooling:Water:HeatExchangerAssisted",
-                                                                              ventSlab.coolingCoilName,
-                                                                              ventSlab.coolingCoilSchedValue,
-                                                                              ventSlab.coolingCoil_Index);
-                break;
-            }
-            default:
-                break;
-            }
-        }
-        case CoilType::None:
-        default:
-            break;
+            case HVAC::CoilType::CoolingWaterHXAssisted: {
+                ventSlab.coolCoilSchedVal = HXAssistCoil::GetCoilScheduleValue(state, ventSlab.coolCoilNum);
+            } break;
+            default: {
+            } break;
+            } // switch (ventSlab.coolCoilType)
         }
 
         // initialize local variables
@@ -2719,12 +2622,10 @@ namespace VentilatedSlab {
                 // On the first HVAC iteration the system values are given to the controller, but after that
                 // the demand limits are in place and there needs to be feedback to the Zone Equipment
 
-                if (!FirstHVACIteration && ventSlab.hCoilType == HeatingCoilType::Water) {
+                if (!FirstHVACIteration && ventSlab.heatCoilType == HVAC::CoilType::HeatingWater) {
                     MaxWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMaxAvail;
                     MinWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMinAvail;
-                }
-
-                if (!FirstHVACIteration && ventSlab.hCoilType == HeatingCoilType::Steam) {
+                } else if (!FirstHVACIteration && ventSlab.heatCoilType == HVAC::CoilType::HeatingSteam) {
                     MaxSteamFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMaxAvail;
                     MinSteamFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMinAvail;
                 }
@@ -2740,7 +2641,7 @@ namespace VentilatedSlab {
 
                 MinOAFrac = min(1.0, max(0.0, MinOAFrac));
 
-                if ((!ventSlab.heatingCoilPresent) || (ventSlab.heatingCoilSchedValue <= 0.0)) {
+                if ((!ventSlab.heatCoilPresent) || (ventSlab.heatCoilSchedVal <= 0.0)) {
                     // In heating mode, but there is no coil to provide heating.  This is handled
                     // differently than if there was a heating coil present.  Fixed temperature
                     // will still try to vary the amount of outside air to meet the desired
@@ -2902,9 +2803,9 @@ namespace VentilatedSlab {
                         (state.dataLoopNodes->Node(OutletNode).MassFlowRate) * CpFan * (RadInTemp - state.dataLoopNodes->Node(FanOutletNode).Temp);
 
                     // Setup the coil configuration
-                    switch (ventSlab.hCoilType) {
+                    switch (ventSlab.heatCoilType) {
 
-                    case HeatingCoilType::Water: {
+                    case HVAC::CoilType::HeatingWater: {
                         // control water flow to obtain output matching QZnReq
 
                         ControlCompOutput(state,
@@ -2925,15 +2826,15 @@ namespace VentilatedSlab {
                                           _,
                                           _,
                                           ventSlab.HWPlantLoc);
-                        break;
-                    }
-                    case HeatingCoilType::Gas:
-                    case HeatingCoilType::Electric:
-                    case HeatingCoilType::Steam: {
+                    } break;
+                      
+                    case HVAC::CoilType::HeatingGasOrOtherFuel:
+                    case HVAC::CoilType::HeatingElectric:
+                    case HVAC::CoilType::HeatingSteam: {
 
                         CalcVentilatedSlabComps(state, Item, FirstHVACIteration, QUnitOut);
-                        break;
-                    }
+                    } break;
+                      
                     default:
                         break;
                     }
@@ -2976,7 +2877,7 @@ namespace VentilatedSlab {
 
                 // On the first HVAC iteration the system values are given to the controller, but after that
                 // the demand limits are in place and there needs to be feedback to the Zone Equipment
-                if ((!FirstHVACIteration) && (ControlNode > 0) && (ventSlab.coolingCoilPresent)) {
+                if ((!FirstHVACIteration) && (ControlNode > 0) && (ventSlab.coolCoilPresent)) {
                     MaxWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMaxAvail;
                     MinWaterFlow = state.dataLoopNodes->Node(ControlNode).MassFlowRateMinAvail;
                 }
@@ -2990,7 +2891,7 @@ namespace VentilatedSlab {
                 }
                 MinOAFrac = min(1.0, max(0.0, MinOAFrac));
 
-                if ((!ventSlab.coolingCoilPresent) || (ventSlab.coolingCoilSchedValue <= 0.0)) {
+                if ((!ventSlab.coolCoilPresent) || (ventSlab.coolCoilSchedVal <= 0.0)) {
                     // In cooling mode, but there is no coil to provide cooling.  This is handled
                     // differently than if there was a cooling coil present.  Fixed temperature
                     // will still try to vary the amount of outside air to meet the desired
@@ -3248,31 +3149,28 @@ namespace VentilatedSlab {
         SimVentSlabOAMixer(state, Item);
         state.dataFans->fans(ventSlab.Fan_Index)->simulate(state, FirstHVACIteration, _, _);
 
-        if ((ventSlab.coolingCoilPresent) && (ventSlab.coolingCoilSchedValue >= 0.0)) {
-            if (ventSlab.cCoilType == CoolingCoilType::HXAssisted) {
-                HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                    ventSlab.coolingCoilName,
-                                                                    FirstHVACIteration,
-                                                                    HVAC::CompressorOp::On,
-                                                                    0.0,
-                                                                    ventSlab.coolingCoil_Index,
-                                                                    HVAC::FanOp::Continuous);
+        if ((ventSlab.coolCoilPresent) && (ventSlab.coolCoilSchedVal >= 0.0)) {
+            if (ventSlab.coolCoilType == HVAC::CoilType::CoolingWaterHXAssisted) {
+                HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                       ventSlab.coolCoilNum,
+                                                       FirstHVACIteration,
+                                                       HVAC::CompressorOp::On,
+                                                       0.0,
+                                                       HVAC::FanOp::Continuous);
             } else {
-                WaterCoils::SimulateWaterCoilComponents(state, ventSlab.coolingCoilName, FirstHVACIteration, ventSlab.coolingCoil_Index);
+                WaterCoils::SimulateWaterCoilComponents(state, ventSlab.coolCoilNum, FirstHVACIteration);
             }
         }
 
-        if ((ventSlab.heatingCoilPresent) && (ventSlab.heatingCoilSchedValue >= 0.0)) {
-
-            switch (ventSlab.hCoilType) {
-
-            case HeatingCoilType::Water: {
+        if ((ventSlab.heatCoilPresent) && (ventSlab.heatCoilSchedVal >= 0.0)) {
 
-                WaterCoils::SimulateWaterCoilComponents(state, ventSlab.heatingCoilName, FirstHVACIteration, ventSlab.heatingCoil_Index);
-                break;
-            }
-            case HeatingCoilType::Steam: {
+            switch (ventSlab.heatCoilType) {
 
+            case HVAC::CoilType::HeatingWater: {
+                WaterCoils::SimulateWaterCoilComponents(state, ventSlab.heatCoilNum, FirstHVACIteration);
+            } break;
+              
+            case HVAC::CoilType::HeatingSteam: {
                 if (!state.dataVentilatedSlab->HCoilOn) {
                     QCoilReq = 0.0;
                 } else {
@@ -3285,11 +3183,11 @@ namespace VentilatedSlab {
 
                 if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
 
-                SteamCoils::SimulateSteamCoilComponents(state, ventSlab.heatingCoilName, FirstHVACIteration, ventSlab.heatingCoil_Index, QCoilReq);
-                break;
-            }
-            case HeatingCoilType::Electric:
-            case HeatingCoilType::Gas: {
+                SteamCoils::SimulateSteamCoilComponents(state, ventSlab.heatCoilNum, FirstHVACIteration, QCoilReq);
+            } break;
+              
+            case HVAC::CoilType::HeatingElectric:
+            case HVAC::CoilType::HeatingGasOrOtherFuel: {
 
                 if (!state.dataVentilatedSlab->HCoilOn) {
                     QCoilReq = 0.0;
@@ -3302,8 +3200,7 @@ namespace VentilatedSlab {
 
                 if (QCoilReq < 0.0) QCoilReq = 0.0; // a heating coil can only heat, not cool
 
-                HeatingCoils::SimulateHeatingCoilComponents(
-                    state, ventSlab.heatingCoilName, FirstHVACIteration, QCoilReq, ventSlab.heatingCoil_Index);
+                HeatingCoils::SimulateHeatingCoilComponents(state, ventSlab.heatCoilNum, FirstHVACIteration, QCoilReq);
                 break;
             }
             default:
@@ -3465,7 +3362,7 @@ namespace VentilatedSlab {
 
         if (state.dataVentilatedSlab->OperatingMode == HeatingMode) {
 
-            if ((!ventSlab.heatingCoilPresent) || (ventSlab.heatingCoilSchedValue <= 0.0)) {
+            if ((!ventSlab.heatCoilPresent) || (ventSlab.heatCoilSchedVal <= 0.0)) {
 
                 AirTempIn = state.dataLoopNodes->Node(FanOutletNode).Temp;
                 state.dataLoopNodes->Node(SlabInNode).Temp =
@@ -3479,7 +3376,7 @@ namespace VentilatedSlab {
 
         if (state.dataVentilatedSlab->OperatingMode == CoolingMode) {
 
-            if ((!ventSlab.coolingCoilPresent) || (ventSlab.coolingCoilSchedValue <= 0.0)) {
+            if ((!ventSlab.coolCoilPresent) || (ventSlab.coolCoilSchedVal <= 0.0)) {
 
                 AirTempIn = state.dataLoopNodes->Node(FanOutletNode).Temp;
                 state.dataLoopNodes->Node(SlabInNode).Temp =
diff --git a/src/EnergyPlus/VentilatedSlab.hh b/src/EnergyPlus/VentilatedSlab.hh
index 4831093db94..31da1bb8033 100644
--- a/src/EnergyPlus/VentilatedSlab.hh
+++ b/src/EnergyPlus/VentilatedSlab.hh
@@ -66,25 +66,6 @@ struct EnergyPlusData;
 
 namespace VentilatedSlab {
 
-    enum class HeatingCoilType
-    {
-        Invalid = -1,
-        Electric,
-        Gas,
-        Water,
-        Steam,
-        Num
-    };
-
-    enum class CoolingCoilType
-    {
-        Invalid = -1,
-        WaterCooling,
-        DetailedCooling,
-        HXAssisted,
-        Num
-    };
-
     // Parameters for outside air control types:
     enum class OutsideAirControlType
     {
@@ -95,7 +76,7 @@ namespace VentilatedSlab {
         Num
     };
 
-    enum class CoilType
+    enum class CoilOption
     {
         Invalid = -1,
         None,
@@ -182,18 +163,18 @@ namespace VentilatedSlab {
         Real64 MinOutAirVolFlow;       // m3/s
         Real64 MinOutAirMassFlow;      // kg/s
         VentilatedSlabConfig SysConfg; // type of coil option; options are BOTH, HEATING, COOLING, AND NONE
-        CoilType coilOption;           // type of coil option; options are BOTH, HEATING, COOLING, AND NONE
-        bool heatingCoilPresent;       // .TRUE. if ventilated slab has a heating coil
-        HeatingCoilType hCoilType;     // type of heating coil (water, gas, electric, etc.)
-        std::string heatingCoilName;   // name of heating coil
-        std::string heatingCoilTypeCh; // type of heating coil (character string)
-        int heatingCoil_Index;
-        DataPlant::PlantEquipmentType heatingCoilType;
-
-        Fluid::RefrigProps *heatingCoil_fluid = nullptr;
-        Sched::Schedule *heatingCoilSched = nullptr; // index to schedule
-
-        Real64 heatingCoilSchedValue;
+        CoilOption coilOption = CoilOption::Invalid;           // type of coil option; options are BOTH, HEATING, COOLING, AND NONE
+
+        bool heatCoilPresent = false;       // .TRUE. if ventilated slab has a heating coil
+        HVAC::CoilType heatCoilType = HVAC::CoilType::Invalid;     // type of heating coil (water, gas, electric, etc.)
+        std::string heatCoilName;   // name of heating coil
+        int heatCoilNum = 0;
+        DataPlant::PlantEquipmentType heatCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+
+        Fluid::RefrigProps *heatCoilFluid = nullptr;
+        Sched::Schedule *heatCoilSched = nullptr; // index to schedule
+
+        Real64 heatCoilSchedVal = 0.0;
         Real64 MaxVolHotWaterFlow; // m3/s
         Real64 MaxVolHotSteamFlow; // m3/s
         Real64 MaxHotWaterFlow;    // kg/s
@@ -214,18 +195,22 @@ namespace VentilatedSlab {
         // (where the highest Air temperature is requested)
         Sched::Schedule *hotCtrlLoTempSched = nullptr; // Schedule for the lowest control temperature
         // (where the highest Air temperature is requested)
-        bool coolingCoilPresent;       // .TRUE. if ventilated slab has a cooling coil
-        std::string coolingCoilName;   // name of cooling coil
-        std::string coolingCoilTypeCh; // type of cooling coil (character string)
-        int coolingCoil_Index;
-        std::string coolingCoilPlantName; // name of cooling coil (child<=CoilSystem:Cooling:Water:HeatExchangerAssisted)
-        std::string coolingCoilPlantType; // type of cooling coil (child<=CoilSystem:Cooling:Water:HeatExchangerAssisted)
-        DataPlant::PlantEquipmentType coolingCoilType;
-        CoolingCoilType cCoilType; // type of cooling coil:
+        bool coolCoilPresent = false;       // .TRUE. if ventilated slab has a cooling coil
+        std::string coolCoilName;   // name of cooling coil
+        int coolCoilNum = 0;
+        HVAC::CoilType coolCoilType = HVAC::CoilType::Invalid; // type of cooling coil:
+
+        std::string childCoolCoilName;
+        HVAC::CoilType childCoolCoilType = HVAC::CoilType::Invalid;
+        int childCoolCoilNum = 0;
+      
+        DataPlant::PlantEquipmentType coolCoilPlantType = DataPlant::PlantEquipmentType::Invalid;
+      
         // 'Coil:Cooling:Water:DetailedGeometry' or
         // 'CoilSystem:Cooling:Water:HeatExchangerAssisted'
-        Sched::Schedule *coolingCoilSched = nullptr;
-        Real64 coolingCoilSchedValue;
+        Sched::Schedule *coolCoilSched = nullptr;
+        Real64 coolCoilSchedVal = 0.0;
+
         Real64 MaxVolColdWaterFlow;                    // m3/s
         Real64 MaxColdWaterFlow;                       // kg/s
         Real64 MinVolColdWaterFlow;                    // m3/s
@@ -292,13 +277,11 @@ namespace VentilatedSlab {
               Fan_Index(0), fanType(HVAC::FanType::Invalid), ControlCompTypeNum(0), CompErrIndex(0), MaxAirVolFlow(0.0), MaxAirMassFlow(0.0),
               outsideAirControlType(OutsideAirControlType::Invalid), OutsideAirNode(0), AirReliefNode(0), OAMixerOutNode(0), OutAirVolFlow(0.0),
               OutAirMassFlow(0.0), MinOutAirVolFlow(0.0), MinOutAirMassFlow(0.0), SysConfg(VentilatedSlabConfig::Invalid),
-              coilOption(CoilType::Invalid), heatingCoilPresent(false), hCoilType(HeatingCoilType::Invalid),
 
-              heatingCoil_Index(0), heatingCoilType(DataPlant::PlantEquipmentType::Invalid), heatingCoilSchedValue(0.0), MaxVolHotWaterFlow(0.0),
+              MaxVolHotWaterFlow(0.0),
               MaxVolHotSteamFlow(0.0), MaxHotWaterFlow(0.0), MaxHotSteamFlow(0.0), MinHotSteamFlow(0.0), MinVolHotWaterFlow(0.0),
               MinVolHotSteamFlow(0.0), MinHotWaterFlow(0.0), HotControlNode(0), HotCoilOutNodeNum(0), HotControlOffset(0.0), HWPlantLoc{},
-              coolingCoilPresent(false), coolingCoil_Index(0), coolingCoilType(DataPlant::PlantEquipmentType::Invalid),
-              cCoilType(CoolingCoilType::Invalid), coolingCoilSchedValue(0.0), MaxVolColdWaterFlow(0.0), MaxColdWaterFlow(0.0),
+              MaxVolColdWaterFlow(0.0), MaxColdWaterFlow(0.0),
               MinVolColdWaterFlow(0.0), MinColdWaterFlow(0.0), ColdControlNode(0), ColdCoilOutNodeNum(0), ColdControlOffset(0.0), CWPlantLoc{},
               CondErrIndex(0), EnrgyImbalErrIndex(0), RadSurfNum(0), MSlabIn(0), MSlabOut(0), DirectHeatLossPower(0.0), DirectHeatLossEnergy(0.0),
               DirectHeatGainPower(0.0), DirectHeatGainEnergy(0.0), TotalVentSlabRadPower(0.0), RadHeatingPower(0.0), RadHeatingEnergy(0.0),
diff --git a/src/EnergyPlus/WaterCoils.cc b/src/EnergyPlus/WaterCoils.cc
index ff3cd4e8a9d..72f5b95334a 100644
--- a/src/EnergyPlus/WaterCoils.cc
+++ b/src/EnergyPlus/WaterCoils.cc
@@ -135,7 +135,7 @@ using Psychrometrics::PsyWFnTdpPb;
 void SimulateWaterCoilComponents(EnergyPlusData &state,
                                  std::string_view CompName,
                                  bool const FirstHVACIteration,
-                                 int &CompIndex,
+                                 int &coilNum,
                                  ObjexxFCL::Optional<Real64> QActual,
                                  ObjexxFCL::Optional<HVAC::FanOp const> fanOpMode,
                                  ObjexxFCL::Optional<Real64 const> PartLoadRatio)
@@ -148,11 +148,6 @@ void SimulateWaterCoilComponents(EnergyPlusData &state,
     // PURPOSE OF THIS SUBROUTINE:
     // This subroutine manages WaterCoil component simulation.
 
-    // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-    int CoilNum;         // The WaterCoil that you are currently loading input into
-    HVAC::FanOp fanOp;   // fan operating mode
-    Real64 PartLoadFrac; // part-load fraction of heating coil
-
     // Obtains and Allocates WaterCoil related parameters from input file
     if (state.dataWaterCoils->GetWaterCoilsInputFlag) { // First time subroutine has been entered
         GetWaterCoilInput(state);
@@ -160,71 +155,77 @@ void SimulateWaterCoilComponents(EnergyPlusData &state,
     }
 
     // Find the correct WaterCoilNumber with the Coil Name
-    if (CompIndex == 0) {
-        CoilNum = Util::FindItemInList(CompName, state.dataWaterCoils->WaterCoil);
-        if (CoilNum == 0) {
+    if (coilNum == 0) {
+        coilNum = Util::FindItemInList(CompName, state.dataWaterCoils->WaterCoil);
+        if (coilNum == 0) {
             ShowFatalError(state, format("SimulateWaterCoilComponents: Coil not found={}", CompName));
         }
-        CompIndex = CoilNum;
     } else {
-        CoilNum = CompIndex;
-        if (CoilNum > state.dataWaterCoils->NumWaterCoils || CoilNum < 1) {
+        if (coilNum > state.dataWaterCoils->NumWaterCoils || coilNum < 1) {
             ShowFatalError(state,
                            format("SimulateWaterCoilComponents: Invalid CompIndex passed={}, Number of Water Coils={}, Coil name={}",
-                                  CoilNum,
+                                  coilNum,
                                   state.dataWaterCoils->NumWaterCoils,
                                   CompName));
         }
-        if (state.dataWaterCoils->CheckEquipName(CoilNum)) {
-            auto const &waterCoil = state.dataWaterCoils->WaterCoil(CoilNum);
+        if (state.dataWaterCoils->CheckEquipName(coilNum)) {
+            auto const &waterCoil = state.dataWaterCoils->WaterCoil(coilNum);
             if (CompName != waterCoil.Name) {
                 ShowFatalError(state,
                                format("SimulateWaterCoilComponents: Invalid CompIndex passed={}, Coil name={}, stored Coil Name for that index={}",
-                                      CoilNum,
+                                      coilNum,
                                       CompName,
                                       waterCoil.Name));
             }
-            state.dataWaterCoils->CheckEquipName(CoilNum) = false;
+            state.dataWaterCoils->CheckEquipName(coilNum) = false;
         }
     }
 
+    SimulateWaterCoilComponents(state, coilNum, FirstHVACIteration, QActual, fanOpMode, PartLoadRatio);
+}
+
+void SimulateWaterCoilComponents(EnergyPlusData &state,
+                                 int const coilNum,
+                                 bool const FirstHVACIteration,
+                                 ObjexxFCL::Optional<Real64> QActual,
+                                 ObjexxFCL::Optional<HVAC::FanOp const> fanOpMode,
+                                 ObjexxFCL::Optional<Real64 const> PartLoadRatio)
+{
+
+    // SUBROUTINE INFORMATION:
+    //       AUTHOR         Richard Liesen
+    //       DATE WRITTEN   February 1998
+
+    // PURPOSE OF THIS SUBROUTINE:
+    // This subroutine manages WaterCoil component simulation.
+
     // With the correct CoilNum Initialize
-    InitWaterCoil(state, CoilNum, FirstHVACIteration); // Initialize all WaterCoil related parameters
+    InitWaterCoil(state, coilNum, FirstHVACIteration); // Initialize all WaterCoil related parameters
 
-    if (present(fanOpMode)) {
-        fanOp = fanOpMode;
-    } else {
-        fanOp = HVAC::FanOp::Continuous;
-    }
-    if (present(PartLoadRatio)) {
-        PartLoadFrac = PartLoadRatio;
-    } else {
-        PartLoadFrac = 1.0;
-    }
+    HVAC::FanOp fanOp = present(fanOpMode) ? fanOpMode() : HVAC::FanOp::Continuous;
+    Real64 PartLoadFrac = present(PartLoadRatio) ? PartLoadRatio() : 1.0;
 
-    auto const &waterCoil = state.dataWaterCoils->WaterCoil(CoilNum);
+    auto const &waterCoil = state.dataWaterCoils->WaterCoil(coilNum);
 
     // Calculate the Correct WaterCoil Model with the current CoilNum
-    if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
-        CalcDetailFlatFinCoolingCoil(state, CoilNum, state.dataWaterCoils->SimCalc, fanOp, PartLoadFrac);
+    if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
+        CalcDetailFlatFinCoolingCoil(state, coilNum, state.dataWaterCoils->SimCalc, fanOp, PartLoadFrac);
         if (present(QActual)) QActual = waterCoil.SenWaterCoolingCoilRate;
-    } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
-        CoolingCoil(state, CoilNum, FirstHVACIteration, state.dataWaterCoils->SimCalc, fanOp, PartLoadFrac);
+    } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
+        CoolingCoil(state, coilNum, FirstHVACIteration, state.dataWaterCoils->SimCalc, fanOp, PartLoadFrac);
         if (present(QActual)) QActual = waterCoil.SenWaterCoolingCoilRate;
-    }
-
-    if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
-        CalcSimpleHeatingCoil(state, CoilNum, fanOp, PartLoadFrac, state.dataWaterCoils->SimCalc);
+    } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+        CalcSimpleHeatingCoil(state, coilNum, fanOp, PartLoadFrac, state.dataWaterCoils->SimCalc);
         if (present(QActual)) QActual = waterCoil.TotWaterHeatingCoilRate;
     }
 
     // Update the current WaterCoil to the outlet nodes
-    UpdateWaterCoil(state, CoilNum);
+    UpdateWaterCoil(state, coilNum);
 
     // Report the current WaterCoil
-    ReportWaterCoil(state, CoilNum);
+    ReportWaterCoil(state, coilNum);
 }
-
+  
 // Get Input Section of the Module
 //******************************************************************************
 
@@ -339,9 +340,8 @@ void GetWaterCoilInput(EnergyPlusData &state)
             ErrorsFound = true;
         }
 
-        waterCoil.WaterCoilModelA = "SIMPLE";
-        waterCoil.WaterCoilModel = CoilModel::HeatingSimple; // 'SIMPLE'
-        waterCoil.WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+        waterCoil.coilType = HVAC::CoilType::HeatingWater;
+        waterCoil.coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
 
         waterCoil.UACoil = NumArray(1);
         waterCoil.UACoilVariable = waterCoil.UACoil;
@@ -506,9 +506,8 @@ void GetWaterCoilInput(EnergyPlusData &state)
             ErrorsFound = true;
         }
 
-        waterCoil.WaterCoilModelA = "DETAILED FLAT FIN";
-        waterCoil.WaterCoilModel = CoilModel::CoolingDetailed; // 'DETAILED FLAT FIN'
-        waterCoil.WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+        waterCoil.coilType = HVAC::CoilType::CoolingWaterDetailed;
+        waterCoil.coilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
 
         waterCoil.MaxWaterVolFlowRate = NumArray(1);
         if (waterCoil.MaxWaterVolFlowRate == DataSizing::AutoSize) waterCoil.RequestingAutoSize = true;
@@ -714,14 +713,17 @@ void GetWaterCoilInput(EnergyPlusData &state)
             ErrorsFound = true;
         }
 
-        waterCoil.WaterCoilModelA = "Cooling";
-        waterCoil.WaterCoilModel = CoilModel::CoolingSimple; // 'Cooling'
-        waterCoil.WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+        waterCoil.coilType = HVAC::CoilType::CoolingWater;
+        waterCoil.coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
 
         waterCoil.MaxWaterVolFlowRate = NumArray(1); // Liquid mass flow rate at Design  kg/s
         if (waterCoil.MaxWaterVolFlowRate == DataSizing::AutoSize) waterCoil.RequestingAutoSize = true;
         waterCoil.DesAirVolFlowRate = NumArray(2); // Dry air mass flow rate at Design (kg/s)
-        if (waterCoil.DesAirVolFlowRate == DataSizing::AutoSize) waterCoil.RequestingAutoSize = true;
+        if (waterCoil.DesAirVolFlowRate == DataSizing::AutoSize) {
+            waterCoil.RequestingAutoSize = true;
+        } else {
+            waterCoil.DesAirVolFlowRateIsAutosized = false;
+        }
         waterCoil.DesInletWaterTemp = NumArray(3); // Entering water temperature at Design C
         if (waterCoil.DesInletWaterTemp == DataSizing::AutoSize) waterCoil.RequestingAutoSize = true;
         waterCoil.DesInletAirTemp = NumArray(4); // Entering air dry bulb temperature at Design(C)
@@ -999,21 +1001,21 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
         for (tempCoilNum = 1; tempCoilNum <= state.dataWaterCoils->NumWaterCoils; ++tempCoilNum) {
             if (state.dataWaterCoils->WaterCoil(tempCoilNum).ControllerIndex > 0) {
                 SimAirServingZones::CompType CoilTypeNum(SimAirServingZones::CompType::Invalid);
-                std::string CompType;
+                HVAC::CoilType coilType = HVAC::CoilType::Invalid;
                 std::string const &CompName = state.dataWaterCoils->WaterCoil(tempCoilNum).Name;
-                if (state.dataWaterCoils->WaterCoil(tempCoilNum).WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
+                if (state.dataWaterCoils->WaterCoil(tempCoilNum).coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
                     CoilTypeNum = SimAirServingZones::CompType::WaterCoil_Cooling;
-                    CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater);
-                } else if (state.dataWaterCoils->WaterCoil(tempCoilNum).WaterCoilType ==
+                    coilType = HVAC::CoilType::CoolingWater;
+                } else if (state.dataWaterCoils->WaterCoil(tempCoilNum).coilPlantType ==
                            DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
                     CoilTypeNum = SimAirServingZones::CompType::WaterCoil_DetailedCool;
-                    CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWaterDetailed);
-                } else if (state.dataWaterCoils->WaterCoil(tempCoilNum).WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+                    coilType = HVAC::CoilType::CoolingWaterDetailed;
+                } else if (state.dataWaterCoils->WaterCoil(tempCoilNum).coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
                     CoilTypeNum = SimAirServingZones::CompType::WaterCoil_SimpleHeat;
-                    CompType = HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater);
+                    coilType = HVAC::CoilType::HeatingWater;
                 }
                 WaterCoilOnAirLoop = true;
-                SimAirServingZones::CheckWaterCoilIsOnAirLoop(state, CoilTypeNum, CompType, CompName, WaterCoilOnAirLoop);
+                SimAirServingZones::CheckWaterCoilIsOnAirLoop(state, CoilTypeNum, coilType, CompName, WaterCoilOnAirLoop);
                 if (!WaterCoilOnAirLoop) {
                     ShowContinueError(state,
                                       format("Controller:WaterCoil = {}. Invalid water controller entry.",
@@ -1031,7 +1033,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
     auto &waterCoil = state.dataWaterCoils->WaterCoil(CoilNum);
     if (state.dataWaterCoils->PlantLoopScanFlag(CoilNum) && allocated(state.dataPlnt->PlantLoop)) {
         errFlag = false;
-        PlantUtilities::ScanPlantLoopsForObject(state, waterCoil.Name, waterCoil.WaterCoilType, waterCoil.WaterPlantLoc, errFlag, _, _, _, _, _);
+        PlantUtilities::ScanPlantLoopsForObject(state, waterCoil.Name, waterCoil.coilPlantType, waterCoil.WaterPlantLoc, errFlag, _, _, _, _, _);
         if (errFlag) {
             ShowFatalError(state, "InitWaterCoil: Program terminated for previous conditions.");
         }
@@ -1063,8 +1065,8 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
         state.dataWaterCoils->DesCpAir(CoilNum) = PsyCpAirFnW(0.0);
         state.dataWaterCoils->DesUARangeCheck(CoilNum) = (-1568.6 * waterCoil.DesInletAirHumRat + 20.157);
 
-        if ((waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
-            (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) { // 'Cooling'
+        if ((waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
+            (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) { // 'Cooling'
             auto &waterInletNode = state.dataLoopNodes->Node(WaterInletNode);
             waterInletNode.Temp = 5.0;
 
@@ -1076,7 +1078,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
             waterInletNode.HumRat = 0.0;
         }
 
-        if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) { // 'Heating'
+        if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) { // 'Heating'
             auto &waterInletNode = state.dataLoopNodes->Node(WaterInletNode);
             waterInletNode.Temp = 60.0;
 
@@ -1102,7 +1104,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
         PlantUtilities::InitComponentNodes(state, 0.0, waterCoil.MaxWaterMassFlowRate, waterCoil.WaterInletNodeNum, waterCoil.WaterOutletNodeNum);
 
         // effective fin diameter for detailed flat fin coil
-        if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+        if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
             waterCoil.EffectiveFinDiam =
                 std::sqrt(4.0 * waterCoil.FinDiam * waterCoil.CoilDepth / (Constant::Pi * waterCoil.NumOfTubeRows * waterCoil.NumOfTubesPerRow));
 
@@ -1164,7 +1166,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
         //@@@ DESIGN CONDITION BEGIN HERE @@@
 
         // Check for zero design cooling capacity as specified by coil design inputs
-        if (state.dataWaterCoils->MyCoilDesignFlag(CoilNum) && (waterCoil.WaterCoilModel == CoilModel::CoolingSimple) &&
+        if (state.dataWaterCoils->MyCoilDesignFlag(CoilNum) && (waterCoil.coilType == HVAC::CoilType::CoolingWater) &&
             (waterCoil.DesAirVolFlowRate > 0.0) && (waterCoil.MaxWaterMassFlowRate > 0.0)) {
 
             DesInletAirEnth = PsyHFnTdbW(waterCoil.DesInletAirTemp, waterCoil.DesInletAirHumRat);
@@ -1197,7 +1199,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
             }
         }
 
-        if (state.dataWaterCoils->MyCoilDesignFlag(CoilNum) && (waterCoil.WaterCoilModel == CoilModel::CoolingSimple) &&
+        if (state.dataWaterCoils->MyCoilDesignFlag(CoilNum) && (waterCoil.coilType == HVAC::CoilType::CoolingWater) &&
             (waterCoil.DesAirVolFlowRate > 0.0) && (waterCoil.MaxWaterMassFlowRate > 0.0)) { // 'Cooling'
 
             state.dataWaterCoils->MyCoilDesignFlag(CoilNum) = false;
@@ -1235,16 +1237,10 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
                             waterCoil.DesOutletAirHumRat = state.dataWaterCoils->WOutNew;
                             waterCoil.DesOutletAirTemp = state.dataWaterCoils->TOutNew;
                             // update outlet air conditions used for sizing
-                            std::string CompType;
-                            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) {
-                                CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWaterDetailed);
-                            } else {
-                                CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater);
-                            }
-                            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(
-                                state, waterCoil.Name, CompType, state.dataWaterCoils->TOutNew);
-                            state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(
-                                state, waterCoil.Name, CompType, state.dataWaterCoils->WOutNew);
+                            ReportCoilSelection::setCoilLvgAirTemp(
+                                state, waterCoil.Name, waterCoil.coilType, state.dataWaterCoils->TOutNew);
+                            ReportCoilSelection::setCoilLvgAirHumRat(
+                                state, waterCoil.Name, waterCoil.coilType, state.dataWaterCoils->WOutNew);
                             // end update outlet air conditions used for sizing
                         }
                     }
@@ -1488,7 +1484,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
         //@@@@ DESIGN CONDITION END HERE @@@@
 
         // Calculate rated Total, latent, sensible capacity, SHR, effectiveness
-        if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+        if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
             waterCoil.InletAirTemp = 16.6;
             waterCoil.InletAirHumRat = PsyWFnTdbRhPb(state, 16.6, 0.5, state.dataEnvrn->StdBaroPress, RoutineName);
             waterCoil.InletWaterTemp = 82.2;
@@ -1507,21 +1503,21 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
         state.dataWaterCoils->CapacitanceWater = waterCoil.InletWaterMassFlowRate * Cp;
         state.dataWaterCoils->CMin = min(CapacitanceAir, state.dataWaterCoils->CapacitanceWater);
         if (state.dataWaterCoils->CMin > 0.0) {
-            if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
+            if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
                 CoolingCoil(state, CoilNum, FirstHVACIteration, state.dataWaterCoils->DesignCalc, HVAC::FanOp::Continuous, 1.0);
                 state.dataWaterCoils->CoilEffectiveness = (waterCoil.InletAirTemp - waterCoil.OutletAirTemp) /
                                                           (waterCoil.InletAirTemp - waterCoil.InletWaterTemp) *
                                                           (CapacitanceAir / state.dataWaterCoils->CMin);
                 state.dataWaterCoils->RatedLatentCapacity = waterCoil.TotWaterCoolingCoilRate - waterCoil.SenWaterCoolingCoilRate;
                 state.dataWaterCoils->RatedSHR = waterCoil.SenWaterCoolingCoilRate / waterCoil.TotWaterCoolingCoilRate;
-            } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
+            } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
                 CalcDetailFlatFinCoolingCoil(state, CoilNum, state.dataWaterCoils->DesignCalc, HVAC::FanOp::Continuous, 1.0);
                 state.dataWaterCoils->CoilEffectiveness = (waterCoil.InletAirTemp - waterCoil.OutletAirTemp) /
                                                           (waterCoil.InletAirTemp - waterCoil.InletWaterTemp) *
                                                           (CapacitanceAir / state.dataWaterCoils->CMin);
                 state.dataWaterCoils->RatedLatentCapacity = waterCoil.TotWaterCoolingCoilRate - waterCoil.SenWaterCoolingCoilRate;
                 state.dataWaterCoils->RatedSHR = waterCoil.SenWaterCoolingCoilRate / waterCoil.TotWaterCoolingCoilRate;
-            } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+            } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
                 CalcSimpleHeatingCoil(state, CoilNum, HVAC::FanOp::Continuous, 1.0, state.dataWaterCoils->DesignCalc);
                 state.dataWaterCoils->CoilEffectiveness = (waterCoil.OutletAirTemp - waterCoil.InletAirTemp) /
                                                           (waterCoil.InletWaterTemp - waterCoil.InletAirTemp) *
@@ -1547,7 +1543,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
         if (state.dataWaterCoils->MyCoilReportFlag(CoilNum)) {
             // create predefined report entries
             state.dataWaterCoils->MyCoilReportFlag(CoilNum) = false;
-            switch (waterCoil.WaterCoilType) {
+            switch (waterCoil.coilPlantType) {
             case DataPlant::PlantEquipmentType::CoilWaterSimpleHeating: {
                 if (state.dataWaterCoils->RptCoilHeaderFlag(1)) {
                     print(state.files.eio, "{}", "! <Water Heating Coil Capacity Information>,Component Type,Name,Nominal Total Capacity {W}\n");
@@ -1568,12 +1564,12 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
                       "Water Heating Coil Capacity Information,Coil:Heating:Water",
                       waterCoil.Name,
                       waterCoil.TotWaterHeatingCoilRate);
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
-                    state, waterCoil.Name, "Coil:Heating:Water", waterCoil.DesAirVolFlowRate, waterCoil.RequestingAutoSize);
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterHeaterCapacityNodeNums(
+                ReportCoilSelection::setCoilAirFlow(
+                    state, waterCoil.Name, HVAC::CoilType::HeatingWater, waterCoil.DesAirVolFlowRate, waterCoil.RequestingAutoSize);
+                ReportCoilSelection::setCoilWaterHeaterCapacityNodeNums(
                     state,
                     waterCoil.Name,
-                    "Coil:Heating:Water",
+                    HVAC::CoilType::HeatingWater,
                     waterCoil.DesWaterHeatingCoilRate,
                     waterCoil.RequestingAutoSize,
                     waterCoil.WaterInletNodeNum,
@@ -1617,14 +1613,14 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
                       waterCoil.SenWaterCoolingCoilRate,
                       state.dataWaterCoils->RatedLatentCapacity,
                       state.dataWaterCoils->RatedSHR);
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(state,
+                ReportCoilSelection::setCoilAirFlow(state,
                                                                                    waterCoil.Name,
-                                                                                   "Coil:Cooling:Water:DetailedGeometry",
+                                                                                   HVAC::CoilType::CoolingWaterDetailed,
                                                                                    waterCoil.DesAirVolFlowRate,
                                                                                    waterCoil.RequestingAutoSize); // Coil Report
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterCoolingCapacity(state,
+                ReportCoilSelection::setCoilWaterCoolingCapacity(state,
                                                                                                 waterCoil.Name,
-                                                                                                "Coil:Cooling:Water:DetailedGeometry",
+                                                                                                HVAC::CoilType::CoolingWaterDetailed,
                                                                                                 waterCoil.DesWaterCoolingCoilRate,
                                                                                                 waterCoil.RequestingAutoSize,
                                                                                                 waterCoil.WaterInletNodeNum,
@@ -1673,14 +1669,14 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
                       state.dataWaterCoils->RatedSHR,
                       state.dataWaterCoils->UATotal,
                       state.dataWaterCoils->SurfaceArea);
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(state,
+                ReportCoilSelection::setCoilAirFlow(state,
                                                                                    waterCoil.Name,
-                                                                                   "Coil:Cooling:Water",
+                                                                                   HVAC::CoilType::CoolingWater,
                                                                                    waterCoil.DesAirVolFlowRate,
                                                                                    waterCoil.RequestingAutoSize); // Coil Report
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterCoolingCapacity(state,
+                ReportCoilSelection::setCoilWaterCoolingCapacity(state,
                                                                                                 waterCoil.Name,
-                                                                                                "Coil:Cooling:Water",
+                                                                                                HVAC::CoilType::CoolingWater,
                                                                                                 waterCoil.DesWaterCoolingCoilRate,
                                                                                                 waterCoil.RequestingAutoSize,
                                                                                                 waterCoil.WaterInletNodeNum,
@@ -1715,18 +1711,18 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
 
             std::string coilTypeName(" ");
             // calculate coil sim model at rating point, full load, continuous fan
-            if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
+            if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
                 CalcDetailFlatFinCoolingCoil(state, CoilNum, state.dataWaterCoils->SimCalc, HVAC::FanOp::Continuous, 1.0);
                 coilTypeName = "Coil:Cooling:Water:DetailedGeometry";
-            } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
+            } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
                 CoolingCoil(state, CoilNum, FirstHVACIteration, state.dataWaterCoils->SimCalc, HVAC::FanOp::Continuous, 1.0);
                 coilTypeName = "Coil:Cooling:Water";
-            } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+            } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
                 CalcSimpleHeatingCoil(state, CoilNum, HVAC::FanOp::Continuous, 1.0, state.dataWaterCoils->SimCalc);
                 coilTypeName = "Coil:Heating:Water";
             }
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilEqNum(
-                state, waterCoil.Name, coilTypeName, state.dataSize->CurSysNum, state.dataSize->CurOASysNum, state.dataSize->CurZoneEqNum);
+            ReportCoilSelection::setCoilEqNum(
+                state, waterCoil.Name, waterCoil.coilType, state.dataSize->CurSysNum, state.dataSize->CurOASysNum, state.dataSize->CurZoneEqNum);
 
             // coil outlets
             Real64 RatedOutletWetBulb(0.0);
@@ -1734,12 +1730,12 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
                 state, waterCoil.OutletAirTemp, waterCoil.OutletAirHumRat, DataEnvironment::StdPressureSeaLevel, "InitWaterCoil");
 
             // call set routine in coil report
-            if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling ||
-                waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
-                state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
+            if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling ||
+                waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
+                ReportCoilSelection::setRatedCoilConditions(
                     state,
                     waterCoil.Name,
-                    coilTypeName,
+                    waterCoil.coilType,
                     waterCoil.TotWaterCoolingCoilRate, // this is the report variable
                     waterCoil.SenWaterCoolingCoilRate, // this is the report variable
                     waterCoil.InletAirMassFlowRate,
@@ -1753,11 +1749,11 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA
                     -999.0,
                     -999.0,
                     -999.0); // coil effectiveness
-            } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
-                state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
+            } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+                ReportCoilSelection::setRatedCoilConditions(
                     state,
                     waterCoil.Name,
-                    coilTypeName,
+                    waterCoil.coilType,
                     waterCoil.TotWaterHeatingCoilRate, // this is the report variable
                     waterCoil.TotWaterHeatingCoilRate, // this is the report variable
                     waterCoil.InletAirMassFlowRate,
@@ -1821,7 +1817,7 @@ void CalcAdjustedCoilUA(EnergyPlusData &state, int const CoilNum)
 
     auto &waterCoil = state.dataWaterCoils->WaterCoil(CoilNum);
     // Coil:Heating:Water
-    if ((waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) &&
+    if ((waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) &&
         (!(state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum)))) { // update Coil UA based on inlet mass flows and temps
         x_a = 1.0 + 4.769E-3 * (waterCoil.InletAirTemp - waterCoil.DesInletAirTemp);
         if (waterCoil.DesAirMassFlowRate > 0.0) {
@@ -1879,7 +1875,7 @@ void CalcAdjustedCoilUA(EnergyPlusData &state, int const CoilNum)
 
     // Coil:Cooling:Water
     // update Coil UA based on inlet mass flows and temps
-    if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling && (!state.dataWaterCoils->MyCoilDesignFlag(CoilNum))) {
+    if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling && (!state.dataWaterCoils->MyCoilDesignFlag(CoilNum))) {
         if (waterCoil.DesAirMassFlowRate > 0.0) {
             x_a = 1.0 + 4.769E-3 * (waterCoil.InletAirTemp - waterCoil.DesInletAirTemp);
             waterCoil.UACoilExternal =
@@ -1999,7 +1995,6 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
 
     // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
     Real64 rho;
-    std::string CompType;                  // component type
     std::string SizingString;              // input field sizing description (e.g., Nominal Capacity)
     Real64 TempSize;                       // autosized value
     Real64 DesCoilWaterInTempSaved;        // coil water inlet temp used for error checking UA sizing
@@ -2016,16 +2011,16 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
 
     auto &waterCoil = state.dataWaterCoils->WaterCoil(CoilNum);
     // cooling coils
-    if (((waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
-         (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) &&
+    if (((waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
+         (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) &&
         waterCoil.RequestingAutoSize) {
         // find the appropriate Plant Sizing object
         PltSizCoolNum = PlantUtilities::MyPlantSizingIndex(
             state, "chilled water coil", waterCoil.Name, waterCoil.WaterInletNodeNum, waterCoil.WaterOutletNodeNum, LoopErrorsFound);
     }
 
-    if (((waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
-         (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling))) { // 'Cooling'
+    if (((waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) ||
+         (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling))) { // 'Cooling'
 
         if (waterCoil.UseDesignWaterDeltaTemp) {
             state.dataSize->DataWaterCoilSizCoolDeltaT = waterCoil.DesignWaterDeltaTemp;
@@ -2041,12 +2036,6 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             state.dataSize->DataPltSizCoolNum = PltSizCoolNum;
             state.dataSize->DataWaterLoopNum = waterCoil.WaterPlantLoc.loopNum;
 
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) {        // 'DETAILED FLAT FIN'
-                CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWaterDetailed); // Coil:Cooling:Water:DetailedGeometry
-            } else {
-                CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater); // Coil:Cooling:Water
-            }
-
             bool bPRINT = false; // do not print this sizing request since the autosized value is needed and this input may not be autosized (we
                                  // should print this!)
             if (waterCoil.DesAirVolFlowRate == state.dataSize->DataFlowUsedForSizing) {
@@ -2058,7 +2047,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             ErrorsFound = false;
             CoolingAirFlowSizer sizingCoolingAirFlow;
             std::string const &CompName = waterCoil.Name;
-            sizingCoolingAirFlow.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizingCoolingAirFlow.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             Real64 autoSizedValue = sizingCoolingAirFlow.size(state, TempSize, ErrorsFound);
             waterCoil.InletAirMassFlowRate = state.dataEnvrn->StdRhoAir * autoSizedValue; // inlet air mass flow rate is the autosized value
 
@@ -2091,23 +2080,23 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
 
             // calculate pre-sizing data needed for specific functions (e.g., CoolingWaterDesAirInletTempSizing needs HRin and air flow)
             // these will be calculated again after other parameters are known
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+            if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                 TempSize = DataSizing::AutoSize;                          // coil report
             } else {
                 TempSize = waterCoil.DesInletAirHumRat; // preserve input if entered
             }
             CoolingWaterDesAirInletHumRatSizer sizerCWDesInHumRat;
-            sizerCWDesInHumRat.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCWDesInHumRat.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             state.dataSize->DataDesInletAirHumRat = sizerCWDesInHumRat.size(state, TempSize, ErrorsFound);
 
             TempSize = DataSizing::AutoSize;
             CoolingCapacitySizer sizerCoolingCapacity;
             sizerCoolingCapacity.overrideSizingString(SizingString);
-            sizerCoolingCapacity.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCoolingCapacity.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             state.dataSize->DataCapacityUsedForSizing = sizerCoolingCapacity.size(state, TempSize, ErrorsFound);
             TempSize = waterCoil.MaxWaterVolFlowRate;
             CoolingWaterflowSizer sizerCWWaterflow;
-            sizerCWWaterflow.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCWWaterflow.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             Real64 autoSizedCWFlow = sizerCWWaterflow.size(state, TempSize, ErrorsFound);
             // Check if the water flow rate is defined in parent HVAC equipment and set water coil design water flow rate accordingly
             if (state.dataSize->CurZoneEqNum > 0) {
@@ -2122,7 +2111,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             }
             // end pre-sizing data calculations
 
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+            if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                 bPRINT = false; // do not print this sizing request since this coil does not have a design inlet air temp input field (we
                                 // should print this!)
                 TempSize = DataSizing::AutoSize; // not an input for this model
@@ -2132,11 +2121,11 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             }
 
             CoolingWaterDesAirInletTempSizer sizerCWDesInletAirTemp;
-            sizerCWDesInletAirTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCWDesInletAirTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.DesInletAirTemp = sizerCWDesInletAirTemp.size(state, TempSize, ErrorsFound);
             state.dataSize->DataDesInletAirTemp = waterCoil.DesInletAirTemp;
 
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+            if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                 bPRINT = false;                                           // no field for detailed water coil, should print to eio anyway
                 TempSize = DataSizing::AutoSize;                          // coil report
             } else {
@@ -2144,11 +2133,11 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 TempSize = waterCoil.DesInletWaterTemp; // preserve input if entered
             }
             CoolingWaterDesWaterInletTempSizer sizerCWDesWaterInTemp;
-            sizerCWDesWaterInTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCWDesWaterInTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.DesInletWaterTemp = sizerCWDesWaterInTemp.size(state, TempSize, ErrorsFound);
 
             if ((waterCoil.DesInletWaterTemp > state.dataSize->DataDesOutletAirTemp) && state.dataSize->DataDesOutletAirTemp > 0.0) {
-                ShowWarningError(state, format("Invalid design inlet water temperature for {} = {}", CompType, CompName));
+                ShowWarningError(state, format("Invalid design inlet water temperature for {} = {}", HVAC::coilTypeNames[(int)waterCoil.coilType], CompName));
                 ShowContinueError(state, format("...design inlet water temperature = {:.3R} C", waterCoil.DesInletWaterTemp));
                 ShowContinueError(state, format("...design outlet air temperature = {:.3R} C", state.dataSize->DataDesOutletAirTemp));
                 ShowContinueError(state, "...design inlet water temperature should be less than the design outlet air temperature");
@@ -2157,18 +2146,18 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             }
 
             if (state.dataSize->CurZoneEqNum > 0) { // zone equipment use air inlet humrat to calculate design outlet air temperature
-                if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+                if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                     bPRINT = false;                                           // no field for detailed water coil, should print to eio anyway
                     TempSize = DataSizing::AutoSize;                          // coil report
                 } else {
                     bPRINT = true;
                     TempSize = waterCoil.DesInletAirHumRat; // preserve input if entered
                 }
-                sizerCWDesInHumRat.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerCWDesInHumRat.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.DesInletAirHumRat = sizerCWDesInHumRat.size(state, TempSize, ErrorsFound);
             }
 
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+            if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                 bPRINT = false;                                           // no field for detailed water coil, should print to eio anyway
                 TempSize = DataSizing::AutoSize;                          // coil report
             } else {
@@ -2178,24 +2167,24 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
 
             state.dataSize->DataDesInletWaterTemp = waterCoil.DesInletWaterTemp; // used for warning messages
             CoolingWaterDesAirOutletTempSizer sizerCWDesAirOutTemp;
-            sizerCWDesAirOutTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCWDesAirOutTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.DesOutletAirTemp = sizerCWDesAirOutTemp.size(state, TempSize, ErrorsFound);
             state.dataSize->DataDesOutletAirTemp = waterCoil.DesOutletAirTemp;
 
             if (state.dataSize->CurSysNum > 0) { // This call can be deleted at a future time and remove the if ( CurZoneEqNum > 0 ) check above. This
                                                  // will change the order of the eio file.
-                if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+                if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                     bPRINT = false;                                           // no field for detailed water coil, should print this to eio anyway
                     TempSize = DataSizing::AutoSize;                          // coil report
                 } else {
                     bPRINT = true;
                     TempSize = waterCoil.DesInletAirHumRat;
                 }
-                sizerCWDesInHumRat.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerCWDesInHumRat.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.DesInletAirHumRat = sizerCWDesInHumRat.size(state, TempSize, ErrorsFound);
             }
 
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+            if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                 bPRINT = false;                                           // no field for detailed water coil, should print this to eio anyway
                 TempSize = DataSizing::AutoSize;                          // coil report
             } else {
@@ -2203,7 +2192,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 TempSize = waterCoil.DesOutletAirHumRat; // preserve input if entered
             }
             CoolingWaterDesAirOutletHumRatSizer sizerCWDesOutHumRat;
-            sizerCWDesOutHumRat.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCWDesOutHumRat.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.DesOutletAirHumRat = sizerCWDesOutHumRat.size(state, TempSize, ErrorsFound);
             state.dataSize->DataDesOutletAirHumRat = waterCoil.DesOutletAirHumRat;
 
@@ -2217,7 +2206,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             state.dataSize->DataDesAccountForFanHeat = false;
             CoolingCapacitySizer sizerCoolingCapacity2;
             sizerCoolingCapacity2.overrideSizingString(SizingString);
-            sizerCoolingCapacity2.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCoolingCapacity2.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.DesWaterCoolingCoilRate = sizerCoolingCapacity2.size(state, TempSize, ErrorsFound);
             waterCoil.InletAirMassFlowRate =
                 state.dataEnvrn->StdRhoAir * state.dataSize->DataFlowUsedForSizing; // inlet air mass flow rate is the autosized value
@@ -2227,33 +2216,46 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             // always based on autosized inputs.
             bPRINT = true;
             TempSize = waterCoil.MaxWaterVolFlowRate;
-            sizerCWWaterflow.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerCWWaterflow.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.MaxWaterVolFlowRate = sizerCWWaterflow.size(state, TempSize, ErrorsFound);
             state.dataSize->DataWaterFlowUsedForSizing = waterCoil.MaxWaterVolFlowRate;
 
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) { // 'DETAILED FLAT FIN'
+            if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) { // 'DETAILED FLAT FIN'
                 bPRINT = false; // do not print this sizing request since this coil does not have a design air flow rate input field (we
                                 // should print this!)
             } else {
                 bPRINT = true;
             }
+#ifdef GET_OUT
+            // Not sure how this snuck in here
+            if (waterCoil.DesAirVolFlowRateIsAutosized && waterCoil.DesAirVolFlowRate > 0.0) {
+                state.dataSize->DataConstantUsedForSizing = 1.0;
+                state.dataSize->DataFractionUsedForSizing = waterCoil.DesAirVolFlowRate;
+                waterCoil.DesAirVolFlowRate = DataSizing::AutoSize;
+            }
+#endif // GET_OUT            
             TempSize = waterCoil.DesAirVolFlowRate;
             CoolingAirFlowSizer sizingCoolingAirFlow2;
             std::string stringOverride = "Design Air Flow Rate [m3/s]";
             if (state.dataGlobal->isEpJSON) stringOverride = "design_air_flow_rate [m3/s]";
             sizingCoolingAirFlow2.overrideSizingString(stringOverride);
             // sizingCoolingAirFlow2.setHVACSizingIndexData(FanCoil(FanCoilNum).HVACSizingIndex);
-            sizingCoolingAirFlow2.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizingCoolingAirFlow2.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.DesAirVolFlowRate = sizingCoolingAirFlow2.size(state, TempSize, ErrorsFound);
             waterCoil.DesAirMassFlowRate = waterCoil.DesAirVolFlowRate * state.dataEnvrn->StdRhoAir;
-
+#ifdef GET_OUT
+            // Not sure how this snuck in here
+            state.dataSize->DataConstantUsedForSizing = 0.0;
+            state.dataSize->DataFractionUsedForSizing = 0.0;
+#endif // GET_OUT
+            
             if (waterCoil.DesAirVolFlowRate <= 0.0) {
                 waterCoil.DesAirVolFlowRate = 0.0;
-                ShowWarningError(state, format("The design air flow rate is zero for {} = {}", CompType, CompName));
+                ShowWarningError(state, format("The design air flow rate is zero for {} = {}", HVAC::coilTypeNames[(int)waterCoil.coilType], CompName));
                 ShowContinueError(state, "The autosize value for max air volume flow rate is zero");
             }
 
-            if (waterCoil.WaterCoilModel == CoilModel::CoolingDetailed) {
+            if (waterCoil.coilType == HVAC::CoilType::CoolingWaterDetailed) {
 
                 int FieldNum = 16; //  N16, \field Number of Tubes per Row
                 bPRINT = true;
@@ -2262,7 +2264,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 state.dataSize->DataFlowUsedForSizing = waterCoil.MaxWaterVolFlowRate;
                 TempSize = float(waterCoil.NumOfTubesPerRow);
                 CoolingWaterNumofTubesPerRowSizer sizerCWNumofTubesPerRow;
-                sizerCWNumofTubesPerRow.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerCWNumofTubesPerRow.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.NumOfTubesPerRow = sizerCWNumofTubesPerRow.size(state, TempSize, ErrorsFound);
 
                 // Auto size water coil fin diameter = 0.335 * WaterCoil( CoilNum ).InletAirMassFlowRate
@@ -2274,7 +2276,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 stringOverride = "Fin Diameter [m]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "fin_diameter [m]";
                 sizerFinDiameter.overrideSizingString(stringOverride);
-                sizerFinDiameter.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerFinDiameter.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.FinDiam = sizerFinDiameter.size(state, TempSize, ErrorsFound);
 
                 // Auto size water coil minimum airflow area = 0.44 * WaterCoil( CoilNum ).InletAirMassFlowRate
@@ -2286,7 +2288,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 stringOverride = "Minimum Airflow Area [m2]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "minimum_airflow_area [m2]";
                 sizerMinAirFlowArea.overrideSizingString(stringOverride);
-                sizerMinAirFlowArea.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerMinAirFlowArea.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.MinAirFlowArea = sizerMinAirFlowArea.size(state, TempSize, ErrorsFound);
 
                 if (waterCoil.MinAirFlowArea <= 0.0) {
@@ -2306,7 +2308,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 stringOverride = "Fin Surface Area [m2]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "fin_surface_area [m2]";
                 sizerFinSurfaceArea.overrideSizingString(stringOverride);
-                sizerFinSurfaceArea.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerFinSurfaceArea.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.FinSurfArea = sizerFinSurfaceArea.size(state, TempSize, ErrorsFound);
 
                 // Auto size water coil total tube inside surface area = 4.4 * WaterCoil( CoilNum ).TubeInsideDiam * WaterCoil( CoilNum
@@ -2319,7 +2321,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 stringOverride = "Total Tube Inside Area [m2]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "total_tube_inside_area [m2]";
                 sizerTubeInsideArea.overrideSizingString(stringOverride);
-                sizerTubeInsideArea.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerTubeInsideArea.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.TotTubeInsideArea = sizerTubeInsideArea.size(state, TempSize, ErrorsFound);
 
                 // Auto size water coil total tube outside surface area = 4.1 * WaterCoil( CoilNum ).TubeOutsideDiam * WaterCoil( CoilNum
@@ -2332,7 +2334,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 stringOverride = "Tube Outside Surface Area [m2]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "tube_outside_surface_area [m2]";
                 sizerTubeOutsideArea.overrideSizingString(stringOverride);
-                sizerTubeOutsideArea.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerTubeOutsideArea.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.TubeOutsideSurfArea = sizerTubeOutsideArea.size(state, TempSize, ErrorsFound);
 
                 if ((waterCoil.FinSurfArea + waterCoil.TubeOutsideSurfArea) <= 0.0) {
@@ -2353,7 +2355,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 stringOverride = "Coil Depth [m]";
                 if (state.dataGlobal->isEpJSON) stringOverride = "coil_depth [m]";
                 sizerCoilDepth.overrideSizingString(stringOverride);
-                sizerCoilDepth.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerCoilDepth.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.CoilDepth = sizerCoilDepth.size(state, TempSize, ErrorsFound);
             }
             state.dataSize->DataPltSizCoolNum = 0; // reset all globals to 0 to ensure correct sizing for other child components
@@ -2383,13 +2385,13 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
     } // end cooling coil IF
 
     // if this is a heating coil
-    if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating && waterCoil.RequestingAutoSize) {
+    if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating && waterCoil.RequestingAutoSize) {
         // find the appropriate heating Plant Sizing object
         PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(
             state, "hot water coil", waterCoil.Name, waterCoil.WaterInletNodeNum, waterCoil.WaterOutletNodeNum, LoopErrorsFound);
     }
 
-    if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+    if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
 
         if (waterCoil.UseDesignWaterDeltaTemp) {
             // use water design deltaT specified in the heating water coils
@@ -2424,19 +2426,18 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             bool bPRINT = false;                                     // do not print this sizing request
             TempSize = DataSizing::AutoSize;                         // get the autosized air volume flow rate for use in other calculations
             SizingString.clear();                                    // doesn't matter
-            CompType = HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater); // "Coil:Heating:Water"
             std::string const &CompName = waterCoil.Name;
             if (waterCoil.DesiccantRegenerationCoil) {
                 state.dataSize->DataDesicRegCoil = true;
                 state.dataSize->DataDesicDehumNum = waterCoil.DesiccantDehumNum;
                 HeatingCoilDesAirInletTempSizer sizerHeatingDesInletTemp;
                 ErrorsFound = false;
-                sizerHeatingDesInletTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHeatingDesInletTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 state.dataSize->DataDesInletAirTemp = sizerHeatingDesInletTemp.size(state, DataSizing::AutoSize, ErrorsFound);
 
                 HeatingCoilDesAirOutletTempSizer sizerHeatingDesOutletTemp;
                 ErrorsFound = false;
-                sizerHeatingDesOutletTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHeatingDesOutletTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 state.dataSize->DataDesOutletAirTemp = sizerHeatingDesOutletTemp.size(state, DataSizing::AutoSize, ErrorsFound);
 
                 if (state.dataSize->CurOASysNum > 0) {
@@ -2450,7 +2451,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             HeatingAirFlowSizer sizingHeatingAirFlow;
             sizingHeatingAirFlow.overrideSizingString(SizingString);
             // sizingHeatingAirFlow.setHVACSizingIndexData(FanCoil(FanCoilNum).HVACSizingIndex);
-            sizingHeatingAirFlow.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizingHeatingAirFlow.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             TempSize = sizingHeatingAirFlow.size(state, TempSize, ErrorsFound);
             // reset the design air volume flow rate for air loop coils only
             if (state.dataSize->CurSysNum > 0) waterCoil.DesAirVolFlowRate = TempSize;
@@ -2471,7 +2472,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 ErrorsFound = false;
                 HeatingCapacitySizer sizerHeatingCapacity;
                 sizerHeatingCapacity.overrideSizingString(SizingString);
-                sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHeatingCapacity.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 TempSize = sizerHeatingCapacity.size(state, TempSize, ErrorsFound);
                 waterCoil.DesWaterHeatingCoilRate = TempSize;
                 waterCoil.DesTotWaterCoilLoad = TempSize;
@@ -2479,7 +2480,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             } else {
                 WaterHeatingCapacitySizer sizerWaterHeatingCapacity;
                 ErrorsFound = false;
-                sizerWaterHeatingCapacity.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerWaterHeatingCapacity.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.DesWaterHeatingCoilRate = sizerWaterHeatingCapacity.size(state, TempSize, ErrorsFound);
                 waterCoil.DesTotWaterCoilLoad = waterCoil.DesWaterHeatingCoilRate;
                 state.dataSize->DataCapacityUsedForSizing = waterCoil.DesWaterHeatingCoilRate;
@@ -2508,7 +2509,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 state.dataSize->DataFractionUsedForSizing = 1.0;
             }
             HeatingWaterflowSizer sizerHWWaterflow;
-            sizerHWWaterflow.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerHWWaterflow.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             Real64 sizedMaxWaterVolFlowRate = sizerHWWaterflow.size(state, TempSize, ErrorsFound);
             // Check if the water flow rate is defined in parent HVAC equipment and set water coil design water flow rate accordingly
             if (state.dataSize->CurZoneEqNum > 0) {
@@ -2552,7 +2553,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 waterCoil.InletAirTemp = state.dataSize->DataDesInletAirTemp;
                 HeatingCoilDesAirInletHumRatSizer sizerHeatingDesInletHumRat;
                 ErrorsFound = false;
-                sizerHeatingDesInletHumRat.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHeatingDesInletHumRat.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.DesInletAirHumRat = sizerHeatingDesInletHumRat.size(state, DataSizing::AutoSize, ErrorsFound);
                 waterCoil.InletAirHumRat = waterCoil.DesInletAirHumRat;
 
@@ -2560,16 +2561,16 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
                 waterCoil.InletAirMassFlowRate = state.dataSize->DataAirFlowUsedForSizing * state.dataEnvrn->StdRhoAir; // this is stiil volume flow!
             } else {
                 HeatingWaterDesAirInletTempSizer sizerHWDesInletTemp;
-                sizerHWDesInletTemp.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHWDesInletTemp.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.InletAirTemp = sizerHWDesInletTemp.size(state, DataSizing::AutoSize, ErrorsFound);
 
                 HeatingWaterDesAirInletHumRatSizer sizerHWAirInletHumRat;
-                sizerHWAirInletHumRat.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHWAirInletHumRat.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.DesInletAirHumRat = sizerHWAirInletHumRat.size(state, DataSizing::AutoSize, ErrorsFound);
                 waterCoil.InletAirHumRat = waterCoil.DesInletAirHumRat;
 
                 HeatingAirflowUASizer sizerHWAirFlowUA;
-                sizerHWAirFlowUA.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHWAirFlowUA.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 waterCoil.DesAirMassFlowRate = sizerHWAirFlowUA.size(state, DataSizing::AutoSize, ErrorsFound);
                 waterCoil.InletAirMassFlowRate = waterCoil.DesAirMassFlowRate;
             }
@@ -2583,11 +2584,11 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             if (!(waterCoil.CoilPerfInpMeth == state.dataWaterCoils->NomCap && NomCapUserInp)) {
                 // get the design coil load used to size UA
                 HeatingWaterDesCoilLoadUsedForUASizer sizerHWDesCoilLoadForUA;
-                sizerHWDesCoilLoadForUA.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHWDesCoilLoadForUA.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 state.dataSize->DataCapacityUsedForSizing = sizerHWDesCoilLoadForUA.size(state, DataSizing::AutoSize, ErrorsFound);
                 // get the water volume flow rate used to size UA
                 HeatingWaterDesCoilWaterVolFlowUsedForUASizer sizerHWWaterVolFlowUA;
-                sizerHWWaterVolFlowUA.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+                sizerHWWaterVolFlowUA.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
                 state.dataSize->DataWaterFlowUsedForSizing = sizerHWWaterVolFlowUA.size(state, DataSizing::AutoSize, ErrorsFound);
                 waterCoil.InletWaterTemp = state.dataSize->PlantSizData(PltSizHeatNum).ExitTemp;
                 waterCoil.InletWaterMassFlowRate = rho * state.dataSize->DataWaterFlowUsedForSizing;
@@ -2623,7 +2624,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum)
             // must set DataCapacityUsedForSizing, DataWaterFlowUsedForSizing and DataFlowUsedForSizing to size UA. Any value of 0 will result
             // in UA = 1.
             WaterHeatingCoilUASizer sizerHWCoilUA;
-            sizerHWCoilUA.initializeWithinEP(state, CompType, CompName, bPRINT, RoutineName);
+            sizerHWCoilUA.initializeWithinEP(state, HVAC::coilTypeNames[(int)waterCoil.coilType], CompName, bPRINT, RoutineName);
             waterCoil.UACoil = sizerHWCoilUA.size(state, TempSize, ErrorsFound);
             if (DesCoilWaterInTempSaved < HVAC::DesCoilHWInletTempMin) {
                 ShowWarningError(state, format("Autosizing of heating coil UA for Coil:Heating:Water \"{}\"", CompName));
@@ -4551,31 +4552,31 @@ void ReportWaterCoil(EnergyPlusData &state, int const CoilNum)
     if (waterCoil.reportCoilFinalSizes) {
         if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
             std::string coilObjClassName;
-            if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
+            if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating) {
                 coilObjClassName = "Coil:Heating:Water";
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
+                ReportCoilSelection::setCoilFinalSizes(state,
                                                                                       waterCoil.Name,
-                                                                                      coilObjClassName,
+                                                                                      waterCoil.coilType,
                                                                                       waterCoil.DesWaterHeatingCoilRate,
                                                                                       waterCoil.DesWaterHeatingCoilRate,
                                                                                       waterCoil.DesAirVolFlowRate,
                                                                                       waterCoil.MaxWaterVolFlowRate);
                 waterCoil.reportCoilFinalSizes = false;
-            } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
+            } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling) {
                 coilObjClassName = "Coil:Cooling:Water:DetailedGeometry";
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
+                ReportCoilSelection::setCoilFinalSizes(state,
                                                                                       waterCoil.Name,
-                                                                                      coilObjClassName,
+                                                                                      waterCoil.coilType,
                                                                                       waterCoil.DesWaterCoolingCoilRate,
                                                                                       -999.0,
                                                                                       waterCoil.DesAirVolFlowRate,
                                                                                       waterCoil.MaxWaterVolFlowRate);
                 waterCoil.reportCoilFinalSizes = false;
-            } else if (waterCoil.WaterCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
+            } else if (waterCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWaterCooling) {
                 coilObjClassName = "Coil:Cooling:Water";
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
+                ReportCoilSelection::setCoilFinalSizes(state,
                                                                                       waterCoil.Name,
-                                                                                      coilObjClassName,
+                                                                                      waterCoil.coilType,
                                                                                       waterCoil.DesWaterCoolingCoilRate,
                                                                                       -999.0,
                                                                                       waterCoil.DesAirVolFlowRate,
@@ -5258,6 +5259,7 @@ Label10:;
     }
 }
 
+#ifdef OLD_API
 void CheckWaterCoilSchedule(EnergyPlusData &state, std::string_view CompName, Real64 &Value, int &CompIndex)
 {
 
@@ -5306,48 +5308,9 @@ Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state,
                                std::string const &CoilName, // must match coil names for the coil type
                                bool &ErrorsFound            // set to true if problem
 )
-{
-
-    // FUNCTION INFORMATION:
-    //       AUTHOR         Linda Lawrie
-    //       DATE WRITTEN   November 2006
-
-    // PURPOSE OF THIS FUNCTION:
-    // This function looks up the max water flow rate for the given coil and returns it.  If
-    // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
-    // as negative.
-
-    // Return value
-    Real64 MaxWaterFlowRate; // returned max water flow rate of matched coil
-
-    // FUNCTION LOCAL VARIABLE DECLARATIONS:
-
-    // Obtains and Allocates WaterCoil related parameters from input file
-    if (state.dataWaterCoils->GetWaterCoilsInputFlag) { // First time subroutine has been entered
-        GetWaterCoilInput(state);
-        state.dataWaterCoils->GetWaterCoilsInputFlag = false;
-    }
-
-    int WhichCoil = 0;
-    if (Util::SameString(CoilType, "Coil:Heating:Water") || Util::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") ||
-        Util::SameString(CoilType, "Coil:Cooling:Water")) {
-        WhichCoil = Util::FindItem(CoilName, state.dataWaterCoils->WaterCoil);
-        if (WhichCoil != 0) {
-            // coil does not specify MaxWaterFlowRate
-            MaxWaterFlowRate = state.dataWaterCoils->WaterCoil(WhichCoil).MaxWaterVolFlowRate;
-        }
-    } else {
-        WhichCoil = 0;
-    }
-
-    if (WhichCoil == 0) {
-        ShowSevereError(state, format("GetCoilMaxWaterFlowRate: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-        ShowContinueError(state, "... Max Water Flow rate returned as -1000.");
-        ErrorsFound = true;
-        MaxWaterFlowRate = -1000.0;
-    }
-
-    return MaxWaterFlowRate;
+{ 
+    int coilNum = GetCoilIndex(state, CoilType, CoilName, ErrorsFound); 
+    return (coilNum != 0) ? state.dataWaterCoils->WaterCoil(coilNum).MaxWaterVolFlowRate : -1000.0;
 }
 
 int GetCoilInletNode(EnergyPlusData &state,
@@ -5356,41 +5319,8 @@ int GetCoilInletNode(EnergyPlusData &state,
                      bool &ErrorsFound            // set to true if problem
 )
 {
-
-    // FUNCTION INFORMATION:
-    //       AUTHOR         R. Raustad
-    //       DATE WRITTEN   March 2007
-
-    // PURPOSE OF THIS FUNCTION:
-    // This function looks up the given coil and returns the inlet node number.  If
-    // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-    // as zero.
-
-    // Obtains and Allocates DXCoils
-    if (state.dataWaterCoils->GetWaterCoilsInputFlag) {
-        GetWaterCoilInput(state);
-        state.dataWaterCoils->GetWaterCoilsInputFlag = false;
-    }
-
-    int NodeNumber = 0;
-    int WhichCoil = 0;
-    if (Util::SameString(CoilType, "Coil:Heating:Water") || Util::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") ||
-        Util::SameString(CoilType, "Coil:Cooling:Water")) {
-        WhichCoil = Util::FindItem(CoilName, state.dataWaterCoils->WaterCoil);
-        if (WhichCoil != 0) {
-            NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).AirInletNodeNum;
-        }
-    } else {
-        WhichCoil = 0;
-    }
-
-    if (WhichCoil == 0) {
-        ShowSevereError(state, format("GetCoilInletNode: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-        ErrorsFound = true;
-        NodeNumber = 0;
-    }
-
-    return NodeNumber;
+    int coilNum = GetCoilIndex(state, CoilType, CoilName, ErrorsFound); 
+    return (coilNum != 0) ? state.dataWaterCoils->WaterCoil(coilNum).AirInletNodeNum : 0;
 }
 
 int GetCoilOutletNode(EnergyPlusData &state,
@@ -5399,43 +5329,8 @@ int GetCoilOutletNode(EnergyPlusData &state,
                       bool &ErrorsFound            // set to true if problem
 )
 {
-
-    // FUNCTION INFORMATION:
-    //       AUTHOR         R. Raustad
-    //       DATE WRITTEN   March 2007
-
-    // PURPOSE OF THIS FUNCTION:
-    // This function looks up the given coil and returns the inlet node number.  If
-    // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-    // as zero.
-
-    // Obtains and Allocates DXCoils
-    if (state.dataWaterCoils->GetWaterCoilsInputFlag) {
-        GetWaterCoilInput(state);
-        state.dataWaterCoils->GetWaterCoilsInputFlag = false;
-    }
-
-    int WhichCoil = 0;
-    int NodeNumber = 0; // returned node number of matched coil
-    if (Util::SameString(CoilType, "Coil:Heating:Water") || Util::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") ||
-        Util::SameString(CoilType, "Coil:Cooling:Water")) {
-        WhichCoil = Util::FindItem(CoilName, state.dataWaterCoils->WaterCoil);
-        if (WhichCoil != 0) {
-            NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).AirOutletNodeNum;
-        }
-    } else {
-        WhichCoil = 0;
-    }
-
-    if (WhichCoil == 0) {
-        ShowSevereError(
-            state,
-            format("GetCoilOutletNode: Could not find Coil, Type=\"{}\" Name=\"{}\" when accessing coil outlet node number.", CoilType, CoilName));
-        ErrorsFound = true;
-        NodeNumber = 0;
-    }
-
-    return NodeNumber;
+    int coilNum = GetCoilIndex(state, CoilType, CoilName, ErrorsFound); 
+    return (coilNum != 0) ? state.dataWaterCoils->WaterCoil(coilNum).AirOutletNodeNum : 0;
 }
 
 int GetCoilWaterInletNode(EnergyPlusData &state,
@@ -5444,41 +5339,8 @@ int GetCoilWaterInletNode(EnergyPlusData &state,
                           bool &ErrorsFound            // set to true if problem
 )
 {
-
-    // FUNCTION INFORMATION:
-    //       AUTHOR         R. Raustad
-    //       DATE WRITTEN   July 2007
-
-    // PURPOSE OF THIS FUNCTION:
-    // This function looks up the given coil and returns the inlet water control node number.  If
-    // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-    // as zero.
-
-    // Obtains and Allocates DXCoils
-    if (state.dataWaterCoils->GetWaterCoilsInputFlag) {
-        GetWaterCoilInput(state);
-        state.dataWaterCoils->GetWaterCoilsInputFlag = false;
-    }
-
-    int NodeNumber = 0; // returned node number of matched coil
-    int WhichCoil = 0;
-    if (Util::SameString(CoilType, "Coil:Heating:Water") || Util::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") ||
-        Util::SameString(CoilType, "Coil:Cooling:Water")) {
-        WhichCoil = Util::FindItem(CoilName, state.dataWaterCoils->WaterCoil);
-        if (WhichCoil != 0) {
-            NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).WaterInletNodeNum;
-        }
-    } else {
-        WhichCoil = 0;
-    }
-
-    if (WhichCoil == 0) {
-        ShowSevereError(state, format("GetCoilWaterInletNode: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-        ErrorsFound = true;
-        NodeNumber = 0;
-    }
-
-    return NodeNumber;
+    int coilNum = GetCoilIndex(state, CoilType, CoilName, ErrorsFound); 
+    return (coilNum != 0) ? state.dataWaterCoils->WaterCoil(coilNum).WaterInletNodeNum : 0;
 }
 
 int GetCoilWaterOutletNode(EnergyPlusData &state,
@@ -5487,43 +5349,41 @@ int GetCoilWaterOutletNode(EnergyPlusData &state,
                            bool &ErrorsFound            // set to true if problem
 )
 {
+    int coilNum = GetCoilIndex(state, CoilType, CoilName, ErrorsFound); 
+    return (coilNum != 0) ? state.dataWaterCoils->WaterCoil(coilNum).WaterOutletNodeNum : 0;
+}
+#endif // OLD_API
 
-    // FUNCTION INFORMATION:
-    //       AUTHOR         R. Raustad
-    //       DATE WRITTEN   July 2007
-
-    // PURPOSE OF THIS FUNCTION:
-    // This function looks up the given coil and returns the outlet water node number.  If
-    // incorrect coil type or name is given, ErrorsFound is returned as true and node number is returned
-    // as zero.
-
-    // Obtains and Allocates DXCoils
-    if (state.dataWaterCoils->GetWaterCoilsInputFlag) {
-        GetWaterCoilInput(state);
-        state.dataWaterCoils->GetWaterCoilsInputFlag = false;
-    }
-
-    int NodeNumber = 0; // returned node number of matched coil
-    int WhichCoil = 0;
-    if (Util::SameString(CoilType, "Coil:Heating:Water") || Util::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") ||
-        Util::SameString(CoilType, "Coil:Cooling:Water")) {
-        WhichCoil = Util::FindItem(CoilName, state.dataWaterCoils->WaterCoil);
-        if (WhichCoil != 0) {
-            NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).WaterOutletNodeNum;
-        }
-    } else {
-        WhichCoil = 0;
-    }
-
-    if (WhichCoil == 0) {
-        ShowSevereError(state, format("GetCoilWaterOutletNode: Could not find Coil, Type=\"{}\" Name=\"{}\"", CoilType, CoilName));
-        ErrorsFound = true;
-        NodeNumber = 0;
-    }
-
-    return NodeNumber;
+Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    return state.dataWaterCoils->WaterCoil(coilNum).MaxWaterVolFlowRate;
 }
 
+int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    return state.dataWaterCoils->WaterCoil(coilNum).AirInletNodeNum;
+}
+  
+int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    return state.dataWaterCoils->WaterCoil(coilNum).AirOutletNodeNum;
+}
+  
+int GetCoilWaterInletNode(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    return state.dataWaterCoils->WaterCoil(coilNum).WaterInletNodeNum;
+}
+  
+int GetCoilWaterOutletNode(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    return state.dataWaterCoils->WaterCoil(coilNum).WaterOutletNodeNum;
+}
+  
 void SetCoilDesFlow(EnergyPlusData &state,
                     std::string_view CoilType,   // must match coil types in this module
                     std::string const &CoilName, // must match coil names for the coil type
@@ -5627,7 +5487,7 @@ void CheckActuatorNode(EnergyPlusData &state,
     for (int CoilNum = 1; CoilNum <= state.dataWaterCoils->NumWaterCoils; ++CoilNum) {
         auto const &waterCoil = state.dataWaterCoils->WaterCoil(CoilNum);
         if (waterCoil.WaterInletNodeNum == ActuatorNodeNum) {
-            WaterCoilType = waterCoil.WaterCoilType;
+            WaterCoilType = waterCoil.coilPlantType;
             NodeNotFound = false;
             break;
         }
@@ -5680,7 +5540,7 @@ void CheckForSensorAndSetPointNode(EnergyPlusData &state,
                 if (EMSSetPointErrorFlag) {
                     if (!SetPointManager::NodeHasSPMCtrlVarType(state, SensorNodeNum, HVAC::CtrlVarType::Temp)) {
                         std::string_view WaterCoilType =
-                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).WaterCoilType)];
+                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).coilPlantType)];
                         ShowWarningError(state, format("{}{}=\"{}\". ", RoutineName, WaterCoilType, state.dataWaterCoils->WaterCoil(WhichCoil).Name));
                         ShowContinueError(state, " ..Temperature setpoint not found on coil air outlet node.");
                         ShowContinueError(state,
@@ -5696,7 +5556,7 @@ void CheckForSensorAndSetPointNode(EnergyPlusData &state,
                 if (EMSSetPointErrorFlag) {
                     if (!SetPointManager::NodeHasSPMCtrlVarType(state, SensorNodeNum, HVAC::CtrlVarType::MaxHumRat)) {
                         std::string_view WaterCoilType =
-                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).WaterCoilType)];
+                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).coilPlantType)];
                         ShowWarningError(state, format("{}{}=\"{}\". ", RoutineName, WaterCoilType, state.dataWaterCoils->WaterCoil(WhichCoil).Name));
                         ShowContinueError(state, " ..Humidity ratio setpoint not found on coil air outlet node.");
                         ShowContinueError(state,
@@ -5712,7 +5572,7 @@ void CheckForSensorAndSetPointNode(EnergyPlusData &state,
                 if (EMSSetPointErrorFlag) {
                     if (!SetPointManager::NodeHasSPMCtrlVarType(state, SensorNodeNum, HVAC::CtrlVarType::Temp)) {
                         std::string_view WaterCoilType =
-                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).WaterCoilType)];
+                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).coilPlantType)];
                         ShowWarningError(state, format("{}{}=\"{}\". ", RoutineName, WaterCoilType, state.dataWaterCoils->WaterCoil(WhichCoil).Name));
                         ShowContinueError(state, " ..Temperature setpoint not found on coil air outlet node.");
                         ShowContinueError(state,
@@ -5726,7 +5586,7 @@ void CheckForSensorAndSetPointNode(EnergyPlusData &state,
                 if (EMSSetPointErrorFlag) {
                     if (!SetPointManager::NodeHasSPMCtrlVarType(state, SensorNodeNum, HVAC::CtrlVarType::MaxHumRat)) {
                         std::string_view WaterCoilType =
-                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).WaterCoilType)];
+                            DataPlant::PlantEquipTypeNames[static_cast<int>(state.dataWaterCoils->WaterCoil(WhichCoil).coilPlantType)];
                         ShowWarningError(state, format("{}{}=\"{}\". ", RoutineName, WaterCoilType, state.dataWaterCoils->WaterCoil(WhichCoil).Name));
                         ShowContinueError(state, " ..Humidity ratio setpoint not found on coil air outlet node.");
                         ShowContinueError(state,
@@ -5859,10 +5719,11 @@ Real64 EstimateHEXSurfaceArea(EnergyPlusData &state, int const CoilNum) // coil
     return waterCoil.UACoilTotal * UOverallHeatTransferCoef_inv; // Heat exchanger surface area [m2]
 }
 
-int GetWaterCoilIndex(EnergyPlusData &state,
-                      std::string_view CoilType,   // must match coil types in this module
-                      std::string const &CoilName, // must match coil names for the coil type
-                      bool &ErrorsFound            // set to true if problem
+#ifdef OLD_API
+int GetCoilIndex(EnergyPlusData &state,
+                 std::string_view const CoilType,   // must match coil types in this module
+                 std::string const &CoilName, // must match coil names for the coil type
+                 bool &ErrorsFound            // set to true if problem
 )
 {
 
@@ -5902,29 +5763,34 @@ int GetWaterCoilIndex(EnergyPlusData &state,
 
     return IndexNum;
 }
-int GetCompIndex(EnergyPlusData &state, CoilModel compType, std::string_view const coilName)
+#endif // OLD_API
+
+int GetCoilIndex(EnergyPlusData &state, std::string const &CoilName)
 {
-    static constexpr std::array<std::string_view, (int)WaterCoils::CoilModel::Num> CoilModelNamesUC = {
-        "COIL:HEATING:WATER", "COIL:COOLING:WATER", "COIL:COOLING:WATER:DETAILED"};
 
+    // FUNCTION INFORMATION:
+    //       AUTHOR         B. Nigusse, FSEC
+    //       DATE WRITTEN   Feb 2012
+
+    // PURPOSE OF THIS FUNCTION:
+    // This function looks up the index for the given coil and returns it.  If incorrect coil
+    // type or name is given, ErrorsFound is returned as true and node number is returned
+    // as zero.
+
+    // Obtains and allocates WaterCoil related parameters from input file
     if (state.dataWaterCoils->GetWaterCoilsInputFlag) {
         GetWaterCoilInput(state);
         state.dataWaterCoils->GetWaterCoilsInputFlag = false;
     }
 
-    int index = Util::FindItemInList(coilName, state.dataWaterCoils->WaterCoil);
-
-    if (index == 0) { // may not find coil name
-        ShowSevereError(state,
-                        format("GetWaterCoilIndex: Could not find CoilType = \"{}\" with Name = \"{}\"", CoilModelNamesUC[(int)compType], coilName));
-    }
-    return index;
+    return Util::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil);
 }
 
-Real64 GetWaterCoilCapacity(EnergyPlusData &state,
-                            std::string const &CoilType, // must match coil types in this module
-                            std::string const &CoilName, // must match coil names for the coil type
-                            bool &ErrorsFound            // set to true if problem
+#ifdef OLD_API
+Real64 GetCoilCapacity(EnergyPlusData &state,
+                       std::string const &CoilType, // must match coil types in this module
+                       std::string const &CoilName, // must match coil names for the coil type
+                       bool &ErrorsFound            // set to true if problem
 )
 {
 
@@ -5966,6 +5832,7 @@ Real64 GetWaterCoilCapacity(EnergyPlusData &state,
 
     return Capacity;
 }
+#endif // OLD_API
 
 void UpdateWaterToAirCoilPlantConnection(EnergyPlusData &state,
                                          DataPlant::PlantEquipmentType const CoilType,
@@ -6019,7 +5886,7 @@ void UpdateWaterToAirCoilPlantConnection(EnergyPlusData &state,
                            CoilName,
                            waterCoil.Name));
             }
-            if (CoilType != waterCoil.WaterCoilType) {
+            if (CoilType != waterCoil.coilPlantType) {
                 ShowFatalError(
                     state,
                     format("UpdateWaterToAirCoilPlantConnection: Invalid CompIndex passed={}, Coil name={}, stored Coil Name for that index={}",
@@ -6064,10 +5931,11 @@ void UpdateWaterToAirCoilPlantConnection(EnergyPlusData &state,
     }
 }
 
-Sched::Schedule *GetWaterCoilAvailSched(EnergyPlusData &state,
-                                        std::string const &CoilType, // must match coil types in this module
-                                        std::string const &CoilName, // must match coil names for the coil type
-                                        bool &ErrorsFound            // set to true if problem
+#ifdef OLD_API
+Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state,
+                                   std::string const &CoilType, // must match coil types in this module
+                                   std::string const &CoilName, // must match coil names for the coil type
+                                   bool &ErrorsFound            // set to true if problem
 )
 {
 
@@ -6107,6 +5975,7 @@ Sched::Schedule *GetWaterCoilAvailSched(EnergyPlusData &state,
 
     return nullptr;
 }
+#endif // OLD_API
 
 void SetWaterCoilData(EnergyPlusData &state,
                       int const CoilNum,                                  // Number of hot water heating Coil
@@ -6258,6 +6127,33 @@ void EstimateCoilInletWaterTemp(EnergyPlusData &state,
     }
 }
 
+void SetCoilDesFlow(EnergyPlusData &state, int const coilNum, Real64 const CoilDesFlow)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    if (state.dataWaterCoils->WaterCoil(coilNum).DesAirVolFlowRate <= 0.0) {
+        state.dataWaterCoils->WaterCoil(coilNum).DesAirVolFlowRate = CoilDesFlow;
+    }
+}
+
+Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    auto const &waterCoil = state.dataWaterCoils->WaterCoil(coilNum);
+    return (waterCoil.coilType == HVAC::CoilType::HeatingWater) ? waterCoil.DesWaterHeatingCoilRate : waterCoil.DesWaterCoolingCoilRate;
+}
+
+Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    return state.dataWaterCoils->WaterCoil(coilNum).availSched;
+}
+ 
+Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum)
+{
+    assert(coilNum > 0 && coilNum <= state.dataWaterCoils->NumWaterCoils);
+    return state.dataWaterCoils->WaterCoil(coilNum).availSched->getCurrentVal(); 
+}
+
 // End of Coil Utility subroutines
 // *****************************************************************************
 
diff --git a/src/EnergyPlus/WaterCoils.hh b/src/EnergyPlus/WaterCoils.hh
index 3c631fc1241..95c03a719c3 100644
--- a/src/EnergyPlus/WaterCoils.hh
+++ b/src/EnergyPlus/WaterCoils.hh
@@ -72,23 +72,13 @@ namespace WaterCoils {
     constexpr Real64 MinWaterMassFlowFrac = 0.000001;
     constexpr Real64 MinAirMassFlow = 0.001;
 
-    enum class CoilModel
-    {
-        Invalid = -1,
-        HeatingSimple,
-        CoolingSimple,
-        CoolingDetailed,
-        Num
-    };
-
     struct WaterCoilEquipConditions
     {
         // Members
         std::string Name;                            // Name of the WaterCoil
-        std::string WaterCoilTypeA;                  // Type of WaterCoil ie. Heating or Cooling
-        std::string WaterCoilModelA;                 // Type of WaterCoil ie. Simple, Detailed, etc.
-        DataPlant::PlantEquipmentType WaterCoilType; // Type of WaterCoil ie. Heating or Cooling
-        CoilModel WaterCoilModel;                    // Type of WaterCoil ie. Simple, Detailed, etc.
+
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;
+        DataPlant::PlantEquipmentType coilPlantType = DataPlant::PlantEquipmentType::Invalid; // Type of WaterCoil ie. Heating or Cooling
         Sched::Schedule *availSched = nullptr;       // availability schedule
         bool RequestingAutoSize;                     // True if this coil has appropriate autosize fields
         Real64 InletAirMassFlowRate;                 // MassFlow through the WaterCoil being Simulated [kg/s]
@@ -157,6 +147,7 @@ namespace WaterCoils {
         // Design Input Variables to the Design Detailed Simple inputs model
         Real64 DesInletWaterTemp;   // Entering water temperature at Design(C)
         Real64 DesAirVolFlowRate;   // Entering Air Volume Flow Rate Design( m3/s)
+        bool DesAirVolFlowRateIsAutosized = true;
         Real64 DesInletAirTemp;     // Entering air dry bulb temperature at Design(C)
         Real64 DesInletAirHumRat;   // Entering air humidity ratio at design conditions
         Real64 DesTotWaterCoilLoad; // Total heat transfer rate at Design(Watt)
@@ -221,7 +212,7 @@ namespace WaterCoils {
 
         // Default Constructor
         WaterCoilEquipConditions()
-            : WaterCoilType(DataPlant::PlantEquipmentType::Invalid), WaterCoilModel(CoilModel::Invalid), RequestingAutoSize(false),
+            : RequestingAutoSize(false),
               InletAirMassFlowRate(0.0), OutletAirMassFlowRate(0.0), InletAirTemp(0.0), OutletAirTemp(0.0), InletAirHumRat(0.0), OutletAirHumRat(0.0),
               InletAirEnthalpy(0.0), OutletAirEnthalpy(0.0), TotWaterCoilLoad(0.0), SenWaterCoilLoad(0.0), TotWaterHeatingCoilEnergy(0.0),
               TotWaterCoolingCoilEnergy(0.0), SenWaterCoolingCoilEnergy(0.0), DesWaterHeatingCoilRate(0.0), TotWaterHeatingCoilRate(0.0),
@@ -270,6 +261,13 @@ namespace WaterCoils {
                                      ObjexxFCL::Optional<HVAC::FanOp const> fanOp = _,
                                      ObjexxFCL::Optional<Real64 const> PartLoadRatio = _);
 
+    void SimulateWaterCoilComponents(EnergyPlusData &state,
+                                     int const coilNum,
+                                     bool const FirstHVACIteration,
+                                     ObjexxFCL::Optional<Real64> QActual = _,
+                                     ObjexxFCL::Optional<HVAC::FanOp const> fanOp = _,
+                                     ObjexxFCL::Optional<Real64 const> PartLoadRatio = _);
+
     void GetWaterCoilInput(EnergyPlusData &state);
 
     void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVACIteration);
@@ -414,21 +412,36 @@ namespace WaterCoils {
                           int &icvg                         // Iteration convergence flag
     );
 
-    void CheckWaterCoilSchedule(EnergyPlusData &state, std::string_view CompName, Real64 &Value, int &CompIndex);
+    int GetCoilIndex(EnergyPlusData &state,
+                     std::string_view const coilType,   // must match coil types in this module
+                     std::string const &coilName, // must match coil names for the coil type
+                     bool &ErrorsFound            // set to true if problem
+    );
 
-    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state,
-                                   std::string_view CoilType,   // must match coil types in this module
-                                   std::string const &CoilName, // must match coil names for the coil type
-                                   bool &ErrorsFound            // set to true if problem
+#ifdef OLD_API  
+    Real64 GetCoilCapacity(EnergyPlusData &state,
+                           std::string_view const coilType, // must match coil types in this module
+                           std::string const &coilName, // must match coil names for the coil type
+                           bool &ErrorsFound            // set to true if problem
     );
 
-    int GetCoilInletNode(EnergyPlusData &state,
+    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state,
+                                       std::string_view const coilType, // must match coil types in this module
+                                       std::string const &coilName, // must match coil names for the coil type
+                                       bool &ErrorsFound            // set to true if problem
+    );
+
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, std::string_view coilType, std::string const &coilName, bool &ErrorsFound);
+  
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, std::string_view coilType, std::string const &coilName, bool &ErrorsFound);
+
+    int GetCoilAirInletNode(EnergyPlusData &state,
                          std::string_view CoilType,   // must match coil types in this module
                          std::string const &CoilName, // must match coil names for the coil type
                          bool &ErrorsFound            // set to true if problem
     );
 
-    int GetCoilOutletNode(EnergyPlusData &state,
+    int GetCoilAirOutletNode(EnergyPlusData &state,
                           std::string_view CoilType,   // must match coil types in this module
                           std::string const &CoilName, // must match coil names for the coil type
                           bool &ErrorsFound            // set to true if problem
@@ -458,7 +471,8 @@ namespace WaterCoils {
                                   std::string const &CoilName, // must match coil names for the coil type
                                   bool &ErrorsFound            // set to true if problem
     );
-
+#endif // OLD_API
+  
     void CheckActuatorNode(EnergyPlusData &state,
                            int const ActuatorNodeNum,                    // input actuator node number
                            DataPlant::PlantEquipmentType &WaterCoilType, // Cooling or Heating or 0
@@ -479,19 +493,6 @@ namespace WaterCoils {
 
     Real64 EstimateHEXSurfaceArea(EnergyPlusData &state, int const CoilNum); // coil number, [-]
 
-    int GetWaterCoilIndex(EnergyPlusData &state,
-                          std::string_view CoilType,   // must match coil types in this module
-                          std::string const &CoilName, // must match coil names for the coil type
-                          bool &ErrorsFound            // set to true if problem
-    );
-    int GetCompIndex(EnergyPlusData &state, CoilModel coilType, std::string_view const coilName);
-
-    Real64 GetWaterCoilCapacity(EnergyPlusData &state,
-                                std::string const &CoilType, // must match coil types in this module
-                                std::string const &CoilName, // must match coil names for the coil type
-                                bool &ErrorsFound            // set to true if problem
-    );
-
     void UpdateWaterToAirCoilPlantConnection(EnergyPlusData &state,
                                              DataPlant::PlantEquipmentType const CoilType,
                                              std::string const &CoilName,
@@ -503,12 +504,6 @@ namespace WaterCoils {
                                              bool &InitLoopEquip // If not zero, calculate the max load for operating conditions
     );
 
-    Sched::Schedule *GetWaterCoilAvailSched(EnergyPlusData &state,
-                                            std::string const &CoilType, // must match coil types in this module
-                                            std::string const &CoilName, // must match coil names for the coil type
-                                            bool &ErrorsFound            // set to true if problem
-    );
-
     // sets data to a coil that is used as a regeneration air heating coil in
     // desiccant dehumidification system
     void SetWaterCoilData(EnergyPlusData &state,
@@ -528,6 +523,31 @@ namespace WaterCoils {
                                     Real64 &DesCoilInletWaterTempUsed // estimated coil design inlet water temperature
     );
 
+      // New API
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
+  
+    Real64 GetCoilScheduleValue(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum);
+  
+    Sched::Schedule *GetCoilAvailSched(EnergyPlusData &state, int const coilNum);
+  
+    Real64 GetCoilMaxWaterFlowRate(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilWaterInletNode(EnergyPlusData &state, int const coilNum);
+  
+    int GetCoilWaterOutletNode(EnergyPlusData &state, int const coilNum);
+  
+    void SetCoilDesFlow(EnergyPlusData &state,
+                        int const coilNum,
+                        Real64 const CoilDesFlow    // coil volumetric air flow rate [m3/s]
+    );
+  
+
 } // namespace WaterCoils
 
 struct WaterCoilsData : BaseGlobalStruct
diff --git a/src/EnergyPlus/WaterThermalTanks.cc b/src/EnergyPlus/WaterThermalTanks.cc
index 78082b188d7..cd8c02cf131 100644
--- a/src/EnergyPlus/WaterThermalTanks.cc
+++ b/src/EnergyPlus/WaterThermalTanks.cc
@@ -415,15 +415,9 @@ void HeatPumpWaterHeaterData::simulate(
             (IntegratedHeatPump::IHPOperationMode::SHDWHElecHeatOn == IHPMode)) { // default is to specify the air nodes for SCWH mode
             bool bDWHCoilReading = false;
             this->HeatPumpAirInletNode =
-                VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state,
-                                                                  "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED",
-                                                                  state.dataIntegratedHP->IntegratedHeatPumps(this->DXCoilNum).DWHCoilName,
-                                                                  bDWHCoilReading);
+                VariableSpeedCoils::GetCoilAirInletNode(state, state.dataIntegratedHP->IntegratedHeatPumps(this->DXCoilNum).DWHCoilNum);
             this->HeatPumpAirOutletNode =
-                VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state,
-                                                                   "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED",
-                                                                   state.dataIntegratedHP->IntegratedHeatPumps(this->DXCoilNum).DWHCoilName,
-                                                                   bDWHCoilReading);
+                VariableSpeedCoils::GetCoilAirOutletNode(state, state.dataIntegratedHP->IntegratedHeatPumps(this->DXCoilNum).DWHCoilNum);
             this->DXCoilAirInletNode = this->HeatPumpAirInletNode;
         } else // default is to input outdoor fan to the HPWH
         {
@@ -808,11 +802,11 @@ bool getDesuperHtrInput(EnergyPlusData &state)
         // Set up comp set for water side nodes (reverse inlet/outlet for water heater)
         BranchNodeConnections::SetUpCompSets(state, DesupHtr.Type, DesupHtr.Name, DesupHtr.TankType, DesupHtr.TankName, cAlphaArgs(6), cAlphaArgs(5));
 
-        std::string const heatSourceObjType = cAlphaArgs(9);
+        DesupHtr.HeatReclaimSourceType = static_cast<HVAC::HeatReclaimType>(getEnumValue(HVAC::heatReclaimTypeNamesUC, cAlphaArgs(9)));
 
-        if ((Util::SameString(heatSourceObjType, "Refrigeration:Condenser:AirCooled")) ||
-            (Util::SameString(heatSourceObjType, "Refrigeration:Condenser:EvaporativeCooled")) ||
-            (Util::SameString(heatSourceObjType, "Refrigeration:Condenser:WaterCooled"))) {
+        if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled || 
+            DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled || 
+            DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled) {
             if (lNumericFieldBlanks(2)) {
                 DesupHtr.HeatReclaimRecoveryEff = 0.8;
             } else {
@@ -846,17 +840,14 @@ bool getDesuperHtrInput(EnergyPlusData &state)
         }     // setting limits on heat recovery efficiency
 
         //       Find the Refrigeration equipment index associated with the desuperheater heating coil.
-        bool errFlag = false;
-        DesupHtr.HeatingSourceType = heatSourceObjType;
-        DesupHtr.HeatingSourceName = cAlphaArgs(10);
-        if (Util::SameString(heatSourceObjType, "Refrigeration:CompressorRack")) {
-            DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::CompressorRackRefrigeratedCase;
+        DesupHtr.HeatReclaimSourceName = cAlphaArgs(10);
+        
+        if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCompressorRack) {
             for (int RackNum = 1; RackNum <= state.dataRefrigCase->NumRefrigeratedRacks; ++RackNum) {
                 if (!Util::SameString(state.dataHeatBal->HeatReclaimRefrigeratedRack(RackNum).Name, cAlphaArgs(10))) continue;
-                DesupHtr.ReclaimHeatingSourceIndexNum = RackNum;
+                DesupHtr.HeatReclaimSourceNum = RackNum;
                 if (allocated(state.dataHeatBal->HeatReclaimRefrigeratedRack)) {
-                    DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                        state.dataHeatBal->HeatReclaimRefrigeratedRack(DesupHtr.ReclaimHeatingSourceIndexNum);
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimRefrigeratedRack(DesupHtr.HeatReclaimSourceNum);
                     if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
                         HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
                         for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
@@ -870,22 +861,21 @@ bool getDesuperHtrInput(EnergyPlusData &state)
                             format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
                                    cCurrentModuleObject,
                                    DesupHtr.Name,
-                                   DesupHtr.HeatingSourceName));
+                                   DesupHtr.HeatReclaimSourceName));
                         ErrorsFound = true;
                     }
                 }
                 break;
             }
-        } else if ((Util::SameString(heatSourceObjType, "Refrigeration:Condenser:AirCooled")) ||
-                   (Util::SameString(heatSourceObjType, "Refrigeration:Condenser:EvaporativeCooled")) ||
-                   (Util::SameString(heatSourceObjType, "Refrigeration:Condenser:WaterCooled"))) {
-            DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::CondenserRefrigeration;
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled || 
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled) {
             for (int CondNum = 1; CondNum <= state.dataRefrigCase->NumRefrigCondensers; ++CondNum) {
                 if (!Util::SameString(state.dataHeatBal->HeatReclaimRefrigCondenser(CondNum).Name, cAlphaArgs(10))) continue;
-                DesupHtr.ReclaimHeatingSourceIndexNum = CondNum;
+                DesupHtr.HeatReclaimSourceNum = CondNum;
                 if (allocated(state.dataHeatBal->HeatReclaimRefrigCondenser)) {
-                    DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                        state.dataHeatBal->HeatReclaimRefrigCondenser(DesupHtr.ReclaimHeatingSourceIndexNum);
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimRefrigCondenser(DesupHtr.HeatReclaimSourceNum);
                     if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
                         HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
                         for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
@@ -899,103 +889,104 @@ bool getDesuperHtrInput(EnergyPlusData &state)
                             format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.9",
                                    cCurrentModuleObject,
                                    DesupHtr.Name,
-                                   DesupHtr.HeatingSourceName));
+                                   DesupHtr.HeatReclaimSourceName));
                         ErrorsFound = true;
                     }
                 }
                 break;
             }
-        } else if (Util::SameString(heatSourceObjType, "Coil:Cooling:DX:SingleSpeed") ||
-                   Util::SameString(heatSourceObjType, "Coil:Cooling:DX:TwoSpeed") ||
-                   Util::SameString(heatSourceObjType, "Coil:Cooling:DX:MultiSpeed") ||
-                   Util::SameString(heatSourceObjType, "Coil:Cooling:DX:TwoStageWithHumidityControlMode")) {
 
-            if (Util::SameString(heatSourceObjType, "Coil:Cooling:DX:SingleSpeed")) {
-                DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::DXCooling;
-            } else if (Util::SameString(heatSourceObjType, "Coil:Cooling:DX:TwoStageWithHumidityControlMode")) {
-                DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::DXMultiMode;
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXSingleSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXTwoSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiMode) { 
+
+            DesupHtr.HeatReclaimSourceNum = DXCoils::GetCoilIndex(state, DesupHtr.HeatReclaimSourceName);
+            if (DesupHtr.HeatReclaimSourceNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(10), DesupHtr.HeatReclaimSourceName);
+                ErrorsFound = true;
             } else {
-                DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::DXMultiSpeed;
-            }
-            DXCoils::GetDXCoilIndex(state, DesupHtr.HeatingSourceName, DesupHtr.ReclaimHeatingSourceIndexNum, errFlag, cCurrentModuleObject);
-            if (allocated(state.dataHeatBal->HeatReclaimDXCoil)) {
-                DataHeatBalance::HeatReclaimDataBase &HeatReclaim = state.dataHeatBal->HeatReclaimDXCoil(DesupHtr.ReclaimHeatingSourceIndexNum);
-                if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
-                    HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
-                    for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
-                        num = 0.0;
-                }
-                DesupHtr.ValidSourceType = true;
-                HeatReclaim.ReclaimEfficiencyTotal += DesupHtr.HeatReclaimRecoveryEff;
-                if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                    ShowSevereError(state,
-                                    format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
-                                           cCurrentModuleObject,
-                                           DesupHtr.Name,
-                                           DesupHtr.HeatingSourceName));
-                    ErrorsFound = true;
+                if (allocated(state.dataHeatBal->HeatReclaimDXCoil)) {
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimDXCoil(DesupHtr.HeatReclaimSourceNum);
+                    if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
+                        HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
+                        for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                            num = 0.0;
+                    }
+                    DesupHtr.ValidSourceType = true;
+                    HeatReclaim.ReclaimEfficiencyTotal += DesupHtr.HeatReclaimRecoveryEff;
+                    if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
+                      ShowSevereError(state,
+                                      format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
+                                             cCurrentModuleObject,
+                                             DesupHtr.Name,
+                                             DesupHtr.HeatReclaimSourceName));
+                      ErrorsFound = true;
+                    }
                 }
             }
-        } else if (Util::SameString(heatSourceObjType, "Coil:Cooling:DX:VariableSpeed") ||
-                   Util::SameString(heatSourceObjType, "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit")) {
-
-            if (Util::SameString(heatSourceObjType, "Coil:Cooling:DX:VariableSpeed")) {
-                DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::DXVariableCooling;
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXVariableSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolWAHPVariableSpeedEquationFit) { 
+            DesupHtr.HeatReclaimSourceNum = VariableSpeedCoils::GetCoilIndex(state, DesupHtr.HeatReclaimSourceName);
+            if (DesupHtr.HeatReclaimSourceNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(10), DesupHtr.HeatReclaimSourceName);
+                ErrorsFound = true;
             } else {
-                DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::AirWaterHeatPumpVSEQ;
-            }
-            DesupHtr.ReclaimHeatingSourceIndexNum = VariableSpeedCoils::GetCoilIndexVariableSpeed(state, heatSourceObjType, cAlphaArgs(10), errFlag);
-            if (allocated(state.dataHeatBal->HeatReclaimVS_Coil)) {
-                DataHeatBalance::HeatReclaimDataBase &HeatReclaim = state.dataHeatBal->HeatReclaimVS_Coil(DesupHtr.ReclaimHeatingSourceIndexNum);
-                if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
-                    HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
-                    for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
-                        num = 0.0;
-                }
-                DesupHtr.ValidSourceType = true;
-                HeatReclaim.ReclaimEfficiencyTotal += DesupHtr.HeatReclaimRecoveryEff;
-                if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                    ShowSevereError(state,
-                                    format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
-                                           cCurrentModuleObject,
-                                           DesupHtr.Name,
-                                           DesupHtr.HeatingSourceName));
-                    ErrorsFound = true;
+                if (allocated(state.dataHeatBal->HeatReclaimVS_Coil)) {
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimVS_Coil(DesupHtr.HeatReclaimSourceNum);
+                    if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
+                        HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
+                        for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                            num = 0.0;
+                    }
+                    DesupHtr.ValidSourceType = true;
+                    HeatReclaim.ReclaimEfficiencyTotal += DesupHtr.HeatReclaimRecoveryEff;
+                    if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
+                        ShowSevereError(state,
+                                        format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
+                                               cCurrentModuleObject,
+                                               DesupHtr.Name,
+                                               DesupHtr.HeatReclaimSourceName));
+                        ErrorsFound = true;
+                    }
                 }
             }
-        } else if (Util::SameString(heatSourceObjType, "Coil:Cooling:WaterToAirHeatPump:EquationFit")) {
-            DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::AirWaterHeatPumpEQ;
-            DesupHtr.ReclaimHeatingSourceIndexNum = WaterToAirHeatPumpSimple::GetCoilIndex(state, heatSourceObjType, cAlphaArgs(10), errFlag);
-            if (allocated(state.dataHeatBal->HeatReclaimSimple_WAHPCoil)) {
-                DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                    state.dataHeatBal->HeatReclaimSimple_WAHPCoil(DesupHtr.ReclaimHeatingSourceIndexNum);
-                if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
-                    HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
-                    for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
-                        num = 0.0;
-                }
-                DesupHtr.ValidSourceType = true;
-                HeatReclaim.ReclaimEfficiencyTotal += DesupHtr.HeatReclaimRecoveryEff;
-                if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
-                    ShowSevereError(state,
-                                    format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
-                                           cCurrentModuleObject,
-                                           DesupHtr.Name,
-                                           DesupHtr.HeatingSourceName));
-                    ErrorsFound = true;
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolWAHPEquationFit) {
+            DesupHtr.HeatReclaimSourceNum = WaterToAirHeatPumpSimple::GetCoilIndex(state, DesupHtr.HeatReclaimSourceName);
+            if (DesupHtr.HeatReclaimSourceNum == 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(10), DesupHtr.HeatReclaimSourceName);
+                ErrorsFound = true;
+            } else {
+            
+                if (allocated(state.dataHeatBal->HeatReclaimSimple_WAHPCoil)) {
+                    auto &HeatReclaim = state.dataHeatBal->HeatReclaimSimple_WAHPCoil(DesupHtr.HeatReclaimSourceNum);
+                    if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
+                        HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
+                        for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                            num = 0.0;
+                    }
+                    DesupHtr.ValidSourceType = true;
+                    HeatReclaim.ReclaimEfficiencyTotal += DesupHtr.HeatReclaimRecoveryEff;
+                    if (HeatReclaim.ReclaimEfficiencyTotal > 0.3) {
+                      ShowSevereError(state,
+                                      format("{} = {}:  sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
+                                             cCurrentModuleObject,
+                                             DesupHtr.Name,
+                                             DesupHtr.HeatReclaimSourceName));
+                      ErrorsFound = true;
+                    }
                 }
             }
-        } else if (Util::SameString(heatSourceObjType, "Coil:Cooling:DX")) {
-            DesupHtr.ReclaimHeatingSource = ReclaimHeatObjectType::CoilCoolingDX;
-            DesupHtr.ReclaimHeatingSourceIndexNum = CoilCoolingDX::factory(state, cAlphaArgs(10));
-            if (DesupHtr.ReclaimHeatingSourceIndexNum < 0) {
-                ShowSevereError(
-                    state,
-                    format("{}={}, could not find desuperheater coil {}={}", cCurrentModuleObject, DesupHtr.Name, cAlphaArgs(9), cAlphaArgs(10)));
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDX) {
+            DesupHtr.HeatReclaimSourceNum = CoilCoolingDX::factory(state, DesupHtr.HeatReclaimSourceName);
+            if (DesupHtr.HeatReclaimSourceNum < 0) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(10), DesupHtr.HeatReclaimSourceName);
                 ErrorsFound = true;
             } else {
-                DataHeatBalance::HeatReclaimDataBase &HeatReclaim =
-                    state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat;
+                auto &HeatReclaim = state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.HeatReclaimSourceNum].reclaimHeat;
                 if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) {
                     HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater);
                     for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
@@ -1009,7 +1000,7 @@ bool getDesuperHtrInput(EnergyPlusData &state)
                         format("{}, \"{}\" sum of heat reclaim recovery efficiencies from the same source coil: \"{}\" cannot be over 0.3",
                                cCurrentModuleObject,
                                DesupHtr.Name,
-                               DesupHtr.HeatingSourceName));
+                               DesupHtr.HeatReclaimSourceName));
                     ErrorsFound = true;
                 }
             }
@@ -1022,21 +1013,12 @@ bool getDesuperHtrInput(EnergyPlusData &state)
                               "Coil:Cooling:WaterToAirHeatPump:EquationFit, Refrigeration:CompressorRack,");
             ShowContinueError(state, " Refrigeration:Condenser:AirCooled ,Refrigeration:Condenser:EvaporativeCooled, ");
             ShowContinueError(state, " or Refrigeration:Condenser:WaterCooled.");
-            ShowContinueError(state, format(" Invalid desuperheater heat source object: {} \"{}\"", heatSourceObjType, cAlphaArgs(10)));
-            ErrorsFound = true;
-        }
-        if (errFlag) {
-            ShowContinueError(state, format("...occurs in {}={}", cCurrentModuleObject, DesupHtr.Name));
+            ShowContinueError(state, format(" Invalid desuperheater heat source object: {} \"{}\"", cAlphaArgs(9), cAlphaArgs(10)));
             ErrorsFound = true;
         }
 
-        if (DesupHtr.ReclaimHeatingSourceIndexNum == 0 && DesupHtr.ReclaimHeatingSource != ReclaimHeatObjectType::CoilCoolingDX) {
-            ShowSevereError(state,
-                            format("{}, \"{}\" desuperheater heat source object not found: {} \"{}\"",
-                                   cCurrentModuleObject,
-                                   DesupHtr.Name,
-                                   heatSourceObjType,
-                                   cAlphaArgs(10)));
+        if (DesupHtr.HeatReclaimSourceNum == 0 && DesupHtr.HeatReclaimSourceType != HVAC::HeatReclaimType::CoilCoolDX) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(10), DesupHtr.HeatReclaimSourceName);
             ErrorsFound = true;
         }
 
@@ -1139,6 +1121,21 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
     // For looking up in IDF/epJSON, you need the index that corresponds to the actual object type (Pumped or Wrapped)
     int HPWaterHeaterNumOfSpecificType;
 
+    std::string cCurrentModuleObject;
+    Array1D<std::string> cAlphaArgs;
+    Array1D<Real64> rNumericArgs;
+    Array1D<bool> lNumericFieldBlanks;
+    Array1D<bool> lAlphaFieldBlanks;
+    Array1D<std::string> cAlphaFieldNames;
+    Array1D<std::string> cNumericFieldNames;
+
+    cAlphaArgs.allocate(30); 
+    cAlphaFieldNames.allocate(30);
+    lAlphaFieldBlanks.allocate(30);
+    rNumericArgs.allocate(11);
+    cNumericFieldNames.allocate(11);
+    lNumericFieldBlanks.allocate(11);
+      
     for (int HPWaterHeaterNum = 1; HPWaterHeaterNum <= state.dataWaterThermalTanks->numHeatPumpWaterHeater; ++HPWaterHeaterNum) {
 
         // Create reference to current HPWH object in array.
@@ -1152,7 +1149,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
 
         if (HPWaterHeaterNum <= NumPumpedCondenser) {
             // Pumped Condenser
-            state.dataIPShortCut->cCurrentModuleObject = cHPWHPumpedCondenser;
+            cCurrentModuleObject = cHPWHPumpedCondenser;
             objType = DataLoopNode::ConnectionObjectType::WaterHeaterHeatPumpPumpedCondenser;
             HPWH.HPWHType = DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped;
             nNumPossibleAlphaArgs = 29;
@@ -1161,10 +1158,10 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             HPWaterHeaterNumOfSpecificType = HPWaterHeaterNum;
         } else {
             // Wrapped Condenser
-            state.dataIPShortCut->cCurrentModuleObject = cHPWHWrappedCondenser;
+            cCurrentModuleObject = cHPWHWrappedCondenser;
             objType = DataLoopNode::ConnectionObjectType::WaterHeaterHeatPumpWrappedCondenser;
             HPWH.HPWHType = DataPlant::PlantEquipmentType::HeatPumpWtrHeaterWrapped;
-            nNumPossibleAlphaArgs = 27;
+            nNumPossibleAlphaArgs = 27; // The "Hungarian" 'n' is short for number so 'nNum' is 'numberNum'.
             nNumPossibleNumericArgs = 10;
             // Actual index of Wrapped type
             HPWaterHeaterNumOfSpecificType = HPWaterHeaterNum - NumPumpedCondenser;
@@ -1174,76 +1171,53 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         int NumNums;
         int IOStat;
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 state.dataIPShortCut->cCurrentModuleObject,
+                                                                 cCurrentModuleObject,
                                                                  HPWaterHeaterNumOfSpecificType,
-                                                                 state.dataIPShortCut->cAlphaArgs,
+                                                                 cAlphaArgs,
                                                                  NumAlphas,
-                                                                 state.dataIPShortCut->rNumericArgs,
+                                                                 rNumericArgs,
                                                                  NumNums,
                                                                  IOStat,
-                                                                 state.dataIPShortCut->lNumericFieldBlanks,
-                                                                 state.dataIPShortCut->lAlphaFieldBlanks,
-                                                                 state.dataIPShortCut->cAlphaFieldNames,
-                                                                 state.dataIPShortCut->cNumericFieldNames);
-
-        ErrorObjectHeader eoh{routineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)};
-
-        // Copy those lists into C++ std::maps // Why, no really why?  This is really dumb
-        std::map<int, std::string> hpwhAlpha;
-        std::map<int, Real64> hpwhNumeric;
-        std::map<int, bool> hpwhAlphaBlank;
-        std::map<int, bool> hpwhNumericBlank;
-        std::map<int, std::string> hpwhAlphaFieldNames;
-        std::map<int, std::string> hpwhNumericFieldNames;
-        for (int i = 1; i <= NumNums; ++i) {
-            hpwhNumeric[i] = state.dataIPShortCut->rNumericArgs(i);
-            hpwhNumericBlank[i] = state.dataIPShortCut->lNumericFieldBlanks(i);
-            hpwhNumericFieldNames[i] = state.dataIPShortCut->cNumericFieldNames(i);
-        }
-        for (int i = NumNums + 1; i <= nNumPossibleNumericArgs; ++i) {
-            hpwhNumericBlank[i] = true;
-        }
-        for (int i = 1; i <= NumAlphas; ++i) {
-            hpwhAlpha[i] = state.dataIPShortCut->cAlphaArgs(i);
-            hpwhAlphaBlank[i] = state.dataIPShortCut->lAlphaFieldBlanks(i);
-            hpwhAlphaFieldNames[i] = state.dataIPShortCut->cAlphaFieldNames(i);
-        }
-        for (int i = NumAlphas + 1; i <= nNumPossibleAlphaArgs; ++i) {
-            hpwhAlphaBlank[i] = true;
-        }
-        Util::IsNameEmpty(state, hpwhAlpha[1], state.dataIPShortCut->cCurrentModuleObject, ErrorsFound);
+                                                                 lNumericFieldBlanks,
+                                                                 lAlphaFieldBlanks,
+                                                                 cAlphaFieldNames,
+                                                                 cNumericFieldNames);
+
+        ErrorObjectHeader eoh{routineName, cCurrentModuleObject, cAlphaArgs(1)};
+
+        Util::IsNameEmpty(state, cAlphaArgs(1), cCurrentModuleObject, ErrorsFound);
 
         // Name and type
-        HPWH.Name = hpwhAlpha[1];
-        HPWH.Type = state.dataIPShortCut->cCurrentModuleObject;
+        HPWH.Name = cAlphaArgs(1);
+        HPWH.Type = cCurrentModuleObject;
 
         // Availability Schedule
         // convert schedule name to pointer
-        if (hpwhAlphaBlank[2]) {
+        if (lAlphaFieldBlanks(2)) {
             HPWH.availSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((HPWH.availSched = Sched::GetSchedule(state, hpwhAlpha[2])) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, hpwhAlphaFieldNames[2], hpwhAlpha[2]);
+        } else if ((HPWH.availSched = Sched::GetSchedule(state, cAlphaArgs(2))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(2), cAlphaArgs(2));
             ErrorsFound = true;
         }
 
         // Compressor Setpoint Temperature Schedule
         // convert schedule name to pointer
-        if (hpwhAlphaBlank[3]) {
-            ShowSevereEmptyField(state, eoh, hpwhAlphaFieldNames[3]);
+        if (lAlphaFieldBlanks(3)) {
+            ShowSevereEmptyField(state, eoh, cAlphaFieldNames(3));
             ErrorsFound = true;
-        } else if ((HPWH.setptTempSched = Sched::GetSchedule(state, hpwhAlpha[3])) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, hpwhAlphaFieldNames[3], hpwhAlpha[3]);
+        } else if ((HPWH.setptTempSched = Sched::GetSchedule(state, cAlphaArgs(3))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(3), cAlphaArgs(3));
             ErrorsFound = true;
         }
 
         // Dead Band Temperature Difference
-        HPWH.DeadBandTempDiff = hpwhNumeric[1 + nNumericOffset];
+        HPWH.DeadBandTempDiff = rNumericArgs(1 + nNumericOffset);
         if (HPWH.DeadBandTempDiff <= 0.0 || HPWH.DeadBandTempDiff > 20.0) {
-            ShowSevereError(state, format("{}=\"{}\", ", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            ShowSevereError(state, format("{}=\"{}\", ", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state,
                               format("{}{}",
-                                     hpwhNumericFieldNames[1 + nNumericOffset],
-                                     format(" difference must be > 0 and <= 20. Dead band = {:.1T}", hpwhNumeric[1 + nNumericOffset])));
+                                     cNumericFieldNames(1 + nNumericOffset),
+                                     format(" difference must be > 0 and <= 20. Dead band = {:.1T}", rNumericArgs(1 + nNumericOffset))));
             ErrorsFound = true;
         }
 
@@ -1251,7 +1225,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
 
             // Condenser Inlet/Outlet Nodes
             HPWH.CondWaterInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                          hpwhAlpha[4],
+                                                                          cAlphaArgs(4),
                                                                           ErrorsFound,
                                                                           objType,
                                                                           HPWH.Name,
@@ -1259,9 +1233,9 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                           DataLoopNode::ConnectionType::Inlet,
                                                                           NodeInputManager::CompFluidStream::Secondary,
                                                                           DataLoopNode::ObjectIsParent);
-            HPWH.InletNodeName1 = hpwhAlpha[4];
+            HPWH.InletNodeName1 = cAlphaArgs(4);
             HPWH.CondWaterOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                           hpwhAlpha[5],
+                                                                           cAlphaArgs(5),
                                                                            ErrorsFound,
                                                                            objType,
                                                                            HPWH.Name,
@@ -1269,39 +1243,39 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                            DataLoopNode::ConnectionType::Outlet,
                                                                            NodeInputManager::CompFluidStream::Secondary,
                                                                            DataLoopNode::ObjectIsParent);
-            HPWH.OutletNodeName1 = hpwhAlpha[5];
+            HPWH.OutletNodeName1 = cAlphaArgs(5);
 
             // Condenser Water Flow Rate
-            HPWH.OperatingWaterFlowRate = hpwhNumeric[2];
-            if (HPWH.OperatingWaterFlowRate <= 0.0 && hpwhNumeric[2] != Constant::AutoCalculate) {
-                ShowSevereError(state, format("{}=\"{}\", ", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            HPWH.OperatingWaterFlowRate = rNumericArgs(2);
+            if (HPWH.OperatingWaterFlowRate <= 0.0 && rNumericArgs(2) != Constant::AutoCalculate) {
+                ShowSevereError(state, format("{}=\"{}\", ", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state,
-                                  format("{} must be greater than 0. Condenser water flow rate = {:.6T}", hpwhNumericFieldNames[2], hpwhNumeric[2]));
+                                  format("{} must be greater than 0. Condenser water flow rate = {:.6T}", cNumericFieldNames(2), rNumericArgs(2)));
                 ErrorsFound = true;
             }
 
         } else if (HPWH.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterWrapped) {
 
             // Wrapped Condenser Location
-            HPWH.WrappedCondenserBottomLocation = hpwhNumeric[2 + nNumericOffset];
-            HPWH.WrappedCondenserTopLocation = hpwhNumeric[3 + nNumericOffset];
+            HPWH.WrappedCondenserBottomLocation = rNumericArgs(2 + nNumericOffset);
+            HPWH.WrappedCondenserTopLocation = rNumericArgs(3 + nNumericOffset);
 
             if (HPWH.WrappedCondenserBottomLocation < 0.0) {
-                ShowSevereError(state, format("{}=\"{}\", ", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowSevereError(state, format("{}=\"{}\", ", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state,
                                   format("{} must be greater than 0. Condenser bottom location = {:.6T}",
-                                         hpwhNumericFieldNames[2],
+                                         cNumericFieldNames(2),
                                          HPWH.WrappedCondenserBottomLocation));
                 ErrorsFound = true;
             }
 
             if (HPWH.WrappedCondenserBottomLocation >= HPWH.WrappedCondenserTopLocation) {
-                ShowSevereError(state, format("{}=\"{}\", ", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowSevereError(state, format("{}=\"{}\", ", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state,
                                   format("{} ({:.6T}) must be greater than {} ({:.6T}).",
                                          HPWH.WrappedCondenserTopLocation,
-                                         hpwhNumericFieldNames[2],
-                                         hpwhNumericFieldNames[3],
+                                         cNumericFieldNames(2),
+                                         cNumericFieldNames(3),
                                          HPWH.WrappedCondenserBottomLocation));
                 ErrorsFound = true;
             }
@@ -1315,40 +1289,40 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         }
 
         // Evaporator Air Flow Rate
-        HPWH.OperatingAirFlowRate = hpwhNumeric[3 + nNumericOffset];
-        if (HPWH.OperatingAirFlowRate <= 0.0 && hpwhNumeric[3 + nNumericOffset] != Constant::AutoCalculate) {
-            ShowSevereError(state, format("{}=\"{}\", ", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+        HPWH.OperatingAirFlowRate = rNumericArgs(3 + nNumericOffset);
+        if (HPWH.OperatingAirFlowRate <= 0.0 && rNumericArgs(3 + nNumericOffset) != Constant::AutoCalculate) {
+            ShowSevereError(state, format("{}=\"{}\", ", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state,
                               format("{}{}",
-                                     hpwhNumericFieldNames[3 + nNumericOffset],
-                                     format(" must be greater than 0. Evaporator air flow rate = {:.6T}", hpwhNumeric[3 + nNumericOffset])));
+                                     cNumericFieldNames(3 + nNumericOffset),
+                                     format(" must be greater than 0. Evaporator air flow rate = {:.6T}", rNumericArgs(3 + nNumericOffset))));
             ErrorsFound = true;
         }
 
         // Inlet Air Configuration
-        HPWH.InletAirConfiguration = static_cast<WTTAmbientTemp>(getEnumValue(HPWHAmbientTempNamesUC, Util::makeUPPER(hpwhAlpha[6 + nAlphaOffset])));
+        HPWH.InletAirConfiguration = static_cast<WTTAmbientTemp>(getEnumValue(HPWHAmbientTempNamesUC, Util::makeUPPER(cAlphaArgs(6 + nAlphaOffset))));
         switch (HPWH.InletAirConfiguration) {
         case WTTAmbientTemp::Schedule: {
 
             // Inlet Air Temperature Schedule
-            if (hpwhAlphaBlank[11 + nAlphaOffset]) {
-                ShowSevereEmptyField(state, eoh, hpwhAlphaFieldNames[11 + nAlphaOffset]);
+            if (lAlphaFieldBlanks(11 + nAlphaOffset)) {
+                ShowSevereEmptyField(state, eoh, cAlphaFieldNames(11 + nAlphaOffset));
                 ErrorsFound = true;
-            } else if ((HPWH.ambientTempSched = Sched::GetSchedule(state, hpwhAlpha[11 + nAlphaOffset])) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, hpwhAlphaFieldNames[11 + nAlphaOffset], hpwhAlpha[11 + nAlphaOffset]);
+            } else if ((HPWH.ambientTempSched = Sched::GetSchedule(state, cAlphaArgs(11 + nAlphaOffset))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(11 + nAlphaOffset), cAlphaArgs(11 + nAlphaOffset));
                 ErrorsFound = true;
             }
 
             // Inlet Air Humidity Schedule
-            if (hpwhAlphaBlank[12 + nAlphaOffset]) {
-                ShowSevereEmptyField(state, eoh, hpwhAlphaFieldNames[12 + nAlphaOffset]);
+            if (lAlphaFieldBlanks(12 + nAlphaOffset)) {
+                ShowSevereEmptyField(state, eoh, cAlphaFieldNames(12 + nAlphaOffset));
                 ErrorsFound = true;
-            } else if ((HPWH.ambientRHSched = Sched::GetSchedule(state, hpwhAlpha[12 + nAlphaOffset])) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, hpwhAlphaFieldNames[12 + nAlphaOffset], hpwhAlpha[12 + nAlphaOffset]);
+            } else if ((HPWH.ambientRHSched = Sched::GetSchedule(state, cAlphaArgs(12 + nAlphaOffset))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(12 + nAlphaOffset), cAlphaArgs(12 + nAlphaOffset));
                 ErrorsFound = true;
             } else if (!HPWH.ambientRHSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
                 Sched::ShowSevereBadMinMax(
-                    state, eoh, hpwhAlphaFieldNames[12 + nAlphaOffset], hpwhAlpha[12 + nAlphaOffset], Clusive::In, 0.0, Clusive::In, 1.0);
+                    state, eoh, cAlphaFieldNames(12 + nAlphaOffset), cAlphaArgs(12 + nAlphaOffset), Clusive::In, 0.0, Clusive::In, 1.0);
                 ErrorsFound = true;
             }
         } break;
@@ -1357,16 +1331,16 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         case WTTAmbientTemp::TempZone: {
 
             // Inlet Air Zone
-            if (!hpwhAlphaBlank[13 + nAlphaOffset]) {
-                HPWH.AmbientTempZone = Util::FindItemInList(hpwhAlpha[13 + nAlphaOffset], state.dataHeatBal->Zone);
+            if (!lAlphaFieldBlanks(13 + nAlphaOffset)) {
+                HPWH.AmbientTempZone = Util::FindItemInList(cAlphaArgs(13 + nAlphaOffset), state.dataHeatBal->Zone);
                 if (HPWH.AmbientTempZone == 0) {
-                    ShowSevereError(state, format("{}=\"{}\", not found", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                    ShowContinueError(state, format("{}=\"{}\".", hpwhAlphaFieldNames[13 + nAlphaOffset], hpwhAlpha[13 + nAlphaOffset]));
+                    ShowSevereError(state, format("{}=\"{}\", not found", cCurrentModuleObject, HPWH.Name));
+                    ShowContinueError(state, format("{}=\"{}\".", cAlphaFieldNames(13 + nAlphaOffset), cAlphaArgs(13 + nAlphaOffset)));
                     ErrorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{}=\"{}\", ", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                ShowContinueError(state, format("required {} is blank.", hpwhAlphaFieldNames[13 + nAlphaOffset]));
+                ShowSevereError(state, format("{}=\"{}\", ", cCurrentModuleObject, HPWH.Name));
+                ShowContinueError(state, format("required {} is blank.", cAlphaFieldNames(13 + nAlphaOffset)));
                 ErrorsFound = true;
             }
             break;
@@ -1376,21 +1350,21 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             break;
         }
 
-        // Read air inlet nodes after mixer/splitter nodes have been read in (state.dataIPShortCut->cAlphaArgs 7-10),
+        // Read air inlet nodes after mixer/splitter nodes have been read in (cAlphaArgs 7-10),
         // Node_ConnectionType differs for inlet node if mixer/splitter node exists
 
         // Tank Name
         // We will verify this exists and is the right kind of tank later when the tanks are all loaded.
-        HPWH.TankName = hpwhAlpha[15 + nAlphaOffset];
-        HPWH.TankType = hpwhAlpha[14 + nAlphaOffset];
+        HPWH.TankName = cAlphaArgs(15 + nAlphaOffset);
+        HPWH.TankType = cAlphaArgs(14 + nAlphaOffset);
 
         // Use Side Inlet/Outlet
         // Get the water heater tank use side inlet node names for HPWHs connected to a plant loop
         // Save the name of the node for use with set up comp sets
-        HPWH.InletNodeName2 = hpwhAlpha[16 + nAlphaOffset];
-        HPWH.OutletNodeName2 = hpwhAlpha[17 + nAlphaOffset];
+        HPWH.InletNodeName2 = cAlphaArgs(16 + nAlphaOffset);
+        HPWH.OutletNodeName2 = cAlphaArgs(17 + nAlphaOffset);
 
-        if (!hpwhAlphaBlank[16 + nAlphaOffset] && !hpwhAlphaBlank[17 + nAlphaOffset]) {
+        if (!lAlphaFieldBlanks(16 + nAlphaOffset) && !lAlphaFieldBlanks(17 + nAlphaOffset)) {
             HPWH.WHUseInletNode = NodeInputManager::GetOnlySingleNode(state,
                                                                       HPWH.InletNodeName2,
                                                                       ErrorsFound,
@@ -1413,88 +1387,59 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
 
         // DX Coil
         // get Coil:DX:HeatPumpWaterHeater object
-        HPWH.DXCoilName = hpwhAlpha[19 + nAlphaOffset];
-        HPWH.DXCoilType = hpwhAlpha[18 + nAlphaOffset];
+        HPWH.DXCoilName = cAlphaArgs(19 + nAlphaOffset);
+        HPWH.DXCoilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, cAlphaArgs(18 + nAlphaOffset)));
 
         // check that the DX Coil exists
         bool DXCoilErrFlag = false;
         bool bIsVScoil = false;
-        DXCoils::GetDXCoilIndex(state, HPWH.DXCoilName, HPWH.DXCoilNum, DXCoilErrFlag, state.dataIPShortCut->cCurrentModuleObject, true);
-        if (DXCoilErrFlag) {
-            // This could be a variable speed heat pump water heater
-            bool bVSCoilErrFlag = false;
-
-            bool checkIHPFirst = IntegratedHeatPump::IHPInModel(state);
-            if (checkIHPFirst) {
-                HPWH.DXCoilNum =
-                    IntegratedHeatPump::GetCoilIndexIHP(state, "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE", HPWH.DXCoilName, bVSCoilErrFlag);
-
-                if (!bVSCoilErrFlag) {
-                    HPWH.bIsIHP = true;
-                }
-            }
-
-            if (bVSCoilErrFlag || !checkIHPFirst) {
-                bVSCoilErrFlag = false;
-                HPWH.DXCoilNum = VariableSpeedCoils::GetCoilIndexVariableSpeed(
-                    state, "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed", HPWH.DXCoilName, bVSCoilErrFlag);
 
-                if (bVSCoilErrFlag) {
-                    ShowContinueError(state, format("...occurs in {} ={}", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                    ShowContinueError(state, format("...could not find either DXCoils::DXCoil or Variable Speed Coil {}", HPWH.DXCoilName));
-                    ErrorsFound = true;
-                }
+        // Try DXCoil first
+        if ((HPWH.DXCoilNum = DXCoils::GetCoilIndex(state, HPWH.DXCoilName)) != 0) {
+            auto &dxCoil = state.dataDXCoils->DXCoil(HPWH.DXCoilNum);
+            if (HPWH.DXCoilType != dxCoil.coilType) {
+                ShowSevereCustom(state, eoh, format("Coil {} expected to be of type {}, but is actually of type {}",
+                                                    HPWH.DXCoilName, HVAC::coilTypeNames[(int)HPWH.DXCoilType], HVAC::coilTypeNames[(int)dxCoil.coilType]));
+                ErrorsFound = true;
             }
-
+        // Then IHP
+        } else if ((HPWH.DXCoilNum = IntegratedHeatPump::GetIHPIndex(state, HPWH.DXCoilName)) != 0) {
+            bIsVScoil = true; // IHPs use variable speed coils
+            HPWH.bIsIHP = true;
+            HPWH.DXCoilType = HVAC::CoilType::IHPAirSource;
+        // Finally VariableSpeedCoil
+        } else if ((HPWH.DXCoilNum = VariableSpeedCoils::GetCoilIndex(state, HPWH.DXCoilName)) != 0) {
             bIsVScoil = true;
-            HPWH.DXCoilTypeNum = 0;
-            if (HPWH.bIsIHP) {
-                HPWH.DXCoilType = "COILSYSTEM:INTEGRATEDHEATPUMP:AIRSOURCE";
-            } else {
-                HPWH.DXCoilType = state.dataVariableSpeedCoils->VarSpeedCoil(HPWH.DXCoilNum).VarSpeedCoilType;
-            }
-        } else {
-            // this is a single speed coil
-            DXCoils::DXCoilData &Coil = state.dataDXCoils->DXCoil(HPWH.DXCoilNum);
-            if (!Util::SameString(HPWH.DXCoilType, Coil.DXCoilType)) {
-                ShowSevereError(state, format("{}=\"{}\", ", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                ShowContinueError(state, format("specifies the coil {}=\"{}\".", HPWH.DXCoilType, HPWH.DXCoilName));
-                ShowContinueError(state, format("However, {} is a coil of type {}.", HPWH.DXCoilName, Coil.DXCoilType));
-                ErrorsFound = true;
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(HPWH.DXCoilNum);
+            if (HPWH.DXCoilType != vsCoil.coilType) {
+                ShowSevereCustom(state, eoh, format("Coil {} expected to be of type {}, but is actually of type {}",
+                                                    HPWH.DXCoilName, HVAC::coilTypeNames[(int)HPWH.DXCoilType], HVAC::coilTypeNames[(int)vsCoil.coilType]));
             }
-            HPWH.DXCoilTypeNum = Coil.DXCoilType_Num;
-        }
+            
+        }          
 
         // Make sure that the coil and tank are compatible.
         if (bIsVScoil) {
             if (HPWH.HPWHType != DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state,
                                   "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed can only be used with a pumped condenser heat pump "
                                   "water heater.");
                 ErrorsFound = true;
             }
         } else {
-            if (!((HPWH.DXCoilTypeNum == HVAC::CoilDX_HeatPumpWaterHeaterPumped &&
+            if (!((HPWH.DXCoilType == HVAC::CoilType::WaterHeatingDXPumped &&
                    HPWH.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped) ||
-                  (HPWH.DXCoilTypeNum == HVAC::CoilDX_HeatPumpWaterHeaterWrapped &&
+                  (HPWH.DXCoilType == HVAC::CoilType::WaterHeatingDXWrapped &&
                    HPWH.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterWrapped))) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                std::string ExpectedCoilType;
-                if (HPWH.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped) {
-                    ExpectedCoilType = HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterPumped);
-                } else if (HPWH.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterWrapped) {
-                    ExpectedCoilType = HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterWrapped);
-                } else {
-                    assert(0);
-                }
-                ShowContinueError(state, format("can only be used with {}", ExpectedCoilType));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
+                ShowContinueError(state, format("can only be used with {}", HVAC::coilTypeNames[(int)HPWH.DXCoilType]));
                 ErrorsFound = true;
             }
         }
 
         // Dummy condenser Inlet/Outlet Nodes for wrapped tanks
-        if (HPWH.DXCoilTypeNum == HVAC::CoilDX_HeatPumpWaterHeaterWrapped) {
+        if (HPWH.DXCoilType == HVAC::CoilType::WaterHeatingDXWrapped) {
             DXCoils::DXCoilData &Coil = state.dataDXCoils->DXCoil(HPWH.DXCoilNum);
 
             HPWH.InletNodeName1 = "DUMMY CONDENSER INLET " + Coil.Name;
@@ -1520,14 +1465,14 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         }
 
         // Minimum Inlet Air Temperature for Compressor Operation
-        HPWH.MinAirTempForHPOperation = hpwhNumeric[4 + nNumericOffset];
+        HPWH.MinAirTempForHPOperation = rNumericArgs(4 + nNumericOffset);
 
         // Maximum Inlet Air Temperature for Compressor Operation
-        HPWH.MaxAirTempForHPOperation = hpwhNumeric[5 + nNumericOffset];
+        HPWH.MaxAirTempForHPOperation = rNumericArgs(5 + nNumericOffset);
         if (HPWH.MaxAirTempForHPOperation <= HPWH.MinAirTempForHPOperation) {
             ShowWarningError(state,
                              format("{}=\"{}\": maximum inlet air temperature for heat pump compressor operation",
-                                    state.dataIPShortCut->cCurrentModuleObject,
+                                    cCurrentModuleObject,
                                     HPWH.Name));
             ShowContinueError(state, "must be greater than the minimum inlet air temperature for heat pump compressor operation.");
             ShowContinueError(state, format("...Minimum inlet air temperature = {:.1T}", HPWH.MinAirTempForHPOperation));
@@ -1536,15 +1481,15 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
 
         // Compressor Location
         HPWH.CrankcaseTempIndicator =
-            static_cast<CrankcaseHeaterControlTemp>(getEnumValue(CrankcaseHeaterControlTempNamesUC, Util::makeUPPER(hpwhAlpha[20 + nAlphaOffset])));
+            static_cast<CrankcaseHeaterControlTemp>(getEnumValue(CrankcaseHeaterControlTempNamesUC, Util::makeUPPER(cAlphaArgs(20 + nAlphaOffset))));
 
         switch (HPWH.CrankcaseTempIndicator) {
         case CrankcaseHeaterControlTemp::Schedule: {
-            if (hpwhAlphaBlank[21 + nAlphaOffset]) {
-                ShowSevereEmptyField(state, eoh, hpwhAlphaFieldNames[21 + nAlphaOffset]);
+            if (lAlphaFieldBlanks(21 + nAlphaOffset)) {
+                ShowSevereEmptyField(state, eoh, cAlphaFieldNames(21 + nAlphaOffset));
                 ErrorsFound = true;
-            } else if ((HPWH.crankcaseTempSched = Sched::GetSchedule(state, hpwhAlpha[21 + nAlphaOffset])) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, hpwhAlphaFieldNames[21 + nAlphaOffset], hpwhAlpha[21 + nAlphaOffset]);
+            } else if ((HPWH.crankcaseTempSched = Sched::GetSchedule(state, cAlphaArgs(21 + nAlphaOffset))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(21 + nAlphaOffset), cAlphaArgs(21 + nAlphaOffset));
                 ErrorsFound = true;
             }
         } break;
@@ -1553,31 +1498,31 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             if (HPWH.InletAirConfiguration == WTTAmbientTemp::OutsideAir || HPWH.InletAirConfiguration == WTTAmbientTemp::Schedule) {
                 ShowSevereError(state,
                                 format("{}=\"{}\":  Inlet Air Configuration must be Zone Air Only or Zone And",
-                                       state.dataIPShortCut->cCurrentModuleObject,
+                                       cCurrentModuleObject,
                                        HPWH.Name));
                 ShowContinueError(state, " Outdoor Air when compressor location equals ZONE.");
                 ErrorsFound = true;
             }
 
-            if (!hpwhAlphaBlank[21 + nAlphaOffset]) {
+            if (!lAlphaFieldBlanks(21 + nAlphaOffset)) {
                 ShowWarningError(state,
                                  format("{}=\"{}\"  {} was provided but will not be used based on compressor location input=\"{}\".",
-                                        state.dataIPShortCut->cCurrentModuleObject,
+                                        cCurrentModuleObject,
                                         HPWH.Name,
-                                        hpwhAlphaFieldNames[21 + nAlphaOffset],
-                                        hpwhAlpha[20 + nAlphaOffset]));
+                                        cAlphaFieldNames(21 + nAlphaOffset),
+                                        cAlphaArgs(20 + nAlphaOffset)));
             }
             break;
         }
         case CrankcaseHeaterControlTemp::Outdoors: {
-            if (!hpwhAlphaBlank[21 + nAlphaOffset]) {
+            if (!lAlphaFieldBlanks(21 + nAlphaOffset)) {
                 ShowWarningError(state,
                                  format("{}=\"{}\"  {} was provided but will not be used based on {}=\"{}\".",
-                                        state.dataIPShortCut->cCurrentModuleObject,
+                                        cCurrentModuleObject,
                                         HPWH.Name,
-                                        hpwhAlphaFieldNames[21 + nAlphaOffset],
-                                        hpwhAlphaFieldNames[21 + nAlphaOffset],
-                                        hpwhAlpha[20 + nAlphaOffset]));
+                                        cAlphaFieldNames(21 + nAlphaOffset),
+                                        cAlphaFieldNames(21 + nAlphaOffset),
+                                        cAlphaArgs(20 + nAlphaOffset)));
             }
             break;
         }
@@ -1586,15 +1531,15 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         }
 
         // Fan Name
-        HPWH.FanName = hpwhAlpha[23 + nAlphaOffset];
+        HPWH.FanName = cAlphaArgs(23 + nAlphaOffset);
 
         Real64 FanVolFlow = 0.0;
         bool errFlag(false);
 
-        HPWH.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, hpwhAlpha[22 + nAlphaOffset]));
+        HPWH.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, cAlphaArgs(22 + nAlphaOffset)));
 
         if ((HPWH.FanNum = Fans::GetFanIndex(state, HPWH.FanName)) == 0) {
-            ShowSevereItemNotFound(state, eoh, hpwhAlphaFieldNames[23 + nAlphaOffset], HPWH.FanName);
+            ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(23 + nAlphaOffset), HPWH.FanName);
             ErrorsFound = true;
         } else {
             assert(HPWH.fanType == state.dataFans->fans(HPWH.FanNum)->type);
@@ -1605,24 +1550,20 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             VariableSpeedCoils::setVarSpeedHPWHFanType(state, HPWH.DXCoilNum, HPWH.fanType);
             VariableSpeedCoils::setVarSpeedHPWHFanIndex(state, HPWH.DXCoilNum, HPWH.FanNum);
         } else {
-            // LOL
-            DXCoils::SetDXCoolingCoilData(state, HPWH.DXCoilNum, errFlag, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, HPWH.FanName);
-            DXCoils::SetDXCoolingCoilData(state, HPWH.DXCoilNum, errFlag, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, HPWH.FanNum);
-            DXCoils::SetDXCoolingCoilData(
-                state, HPWH.DXCoilNum, errFlag, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, HPWH.fanType);
+            DXCoils::SetCoilSupplyFanInfo(state, HPWH.DXCoilNum, HPWH.FanNum, HPWH.FanName, HPWH.fanType);
         }
 
         if (errFlag) {
             ErrorsFound = true;
         } else if (HPWH.fanType != HVAC::FanType::OnOff && HPWH.fanType != HVAC::FanType::SystemModel) {
-            ShowSevereError(state, format("{}=\"{}\": illegal fan type specified.", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            ShowSevereError(state, format("{}=\"{}\": illegal fan type specified.", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(
                 state,
                 format(" The fan object ({}) type must be Fan:SystemModel or Fan:OnOff when used with a heat pump water heater.", HPWH.FanName));
             ErrorsFound = true;
         } else if (HPWH.fanType != HVAC::FanType::OnOff && HPWH.fanType != HVAC::FanType::SystemModel) {
-            ShowSevereError(state, format("{}=\"{}\": illegal fan type specified.", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-            ShowContinueError(state, format(" The {} must specify that the fan object", state.dataIPShortCut->cCurrentModuleObject));
+            ShowSevereError(state, format("{}=\"{}\": illegal fan type specified.", cCurrentModuleObject, HPWH.Name));
+            ShowContinueError(state, format(" The {} must specify that the fan object", cCurrentModuleObject));
             ShowContinueError(state,
                               " is of type FanSystemModel or Fan:OnOff in addition to the fan actually being of that type and defined elsewhere.");
         }
@@ -1631,7 +1572,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             if (FanVolFlow < HPWH.OperatingAirFlowRate) {
                 ShowSevereError(state,
                                 format("{} - air flow rate = {:.7T} in fan object {} is less than the  HPWHs evaporator air flow rate.",
-                                       state.dataIPShortCut->cCurrentModuleObject,
+                                       cCurrentModuleObject,
                                        FanVolFlow,
                                        HPWH.FanName));
                 ShowContinueError(state, " The fan flow rate must be >= to the HPWHs evaporator volumetric air flow rate.");
@@ -1641,42 +1582,40 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         }
 
         // Fan Placement
-        HPWH.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, hpwhAlpha[24 + nAlphaOffset]));
+        HPWH.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, cAlphaArgs(24 + nAlphaOffset)));
         if (HPWH.fanPlace == HVAC::FanPlace::Invalid) {
-            ShowSevereInvalidKey(state, eoh, hpwhAlphaFieldNames[24 + nAlphaOffset], hpwhAlpha[24 + nAlphaOffset]);
+            ShowSevereInvalidKey(state, eoh, cAlphaFieldNames(24 + nAlphaOffset), cAlphaArgs(24 + nAlphaOffset));
             ErrorsFound = true;
         }
 
         if (HPWH.DXCoilNum > 0 && !bIsVScoil) {
+            auto const &dxCoil = state.dataDXCoils->DXCoil(HPWH.DXCoilNum);
             // get HPWH capacity, air inlet node, and PLF curve info from DX coil object
-            HPWH.Capacity = state.dataDXCoils->DXCoil(HPWH.DXCoilNum).RatedTotCap2;
-            HPWH.DXCoilAirInletNode = state.dataDXCoils->DXCoil(HPWH.DXCoilNum).AirInNode;
-            HPWH.DXCoilPLFFPLR = state.dataDXCoils->DXCoil(HPWH.DXCoilNum).PLFFPLR(1);
+            HPWH.Capacity = dxCoil.RatedTotCap2;
+            HPWH.DXCoilAirInletNode = dxCoil.AirInNode;
+            HPWH.DXCoilPLFFPLR = dxCoil.PLFFPLR(1);
             // check the range of condenser pump power to be <= 5 gpm/ton
-            if (state.dataDXCoils->DXCoil(HPWH.DXCoilNum).HPWHCondPumpElecNomPower / state.dataDXCoils->DXCoil(HPWH.DXCoilNum).RatedTotCap2 >
+            if (dxCoil.HPWHCondPumpElecNomPower / dxCoil.RatedTotCap2 >
                 0.1422) {
                 ShowWarningError(
                     state,
                     format("{}= {}{}",
-                           state.dataDXCoils->DXCoil(HPWH.DXCoilNum).DXCoilType,
-                           state.dataDXCoils->DXCoil(HPWH.DXCoilNum).Name,
+                           HVAC::coilTypeNames[(int)dxCoil.coilType],
+                           dxCoil.Name,
                            format(": Rated condenser pump power per watt of rated heating capacity has exceeded the recommended maximum of 0.1422 "
                                   "W/W (41.67 watt/MBH). Condenser pump power per watt = {:.4T}",
-                                  (state.dataDXCoils->DXCoil(HPWH.DXCoilNum).HPWHCondPumpElecNomPower /
-                                   state.dataDXCoils->DXCoil(HPWH.DXCoilNum).RatedTotCap2))));
+                                  (dxCoil.HPWHCondPumpElecNomPower / dxCoil.RatedTotCap2))));
             }
         } else if ((HPWH.DXCoilNum > 0) && (bIsVScoil)) {
 
             if (HPWH.bIsIHP) {
-                HPWH.Capacity =
-                    GetDWHCoilCapacityIHP(state, HPWH.DXCoilType, HPWH.DXCoilName, IntegratedHeatPump::IHPOperationMode::SCWHMatchWH, DXCoilErrFlag);
-                HPWH.DXCoilAirInletNode = IntegratedHeatPump::GetCoilInletNodeIHP(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
-                HPWH.DXCoilPLFFPLR =
-                    GetIHPDWHCoilPLFFPLR(state, HPWH.DXCoilType, HPWH.DXCoilName, IntegratedHeatPump::IHPOperationMode::SCWHMatchWH, DXCoilErrFlag);
+                HPWH.Capacity = IntegratedHeatPump::GetIHPDWHCoilCapacity(state, HPWH.DXCoilNum);
+                HPWH.DXCoilAirInletNode = IntegratedHeatPump::GetIHPCoilAirInletNode(state, HPWH.DXCoilNum);
+                HPWH.DXCoilPLFFPLR = IntegratedHeatPump::GetIHPDWHCoilPLFFPLR(state, HPWH.DXCoilNum);
             } else {
-                HPWH.Capacity = VariableSpeedCoils::GetCoilCapacityVariableSpeed(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
-                HPWH.DXCoilAirInletNode = VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
-                HPWH.DXCoilPLFFPLR = VariableSpeedCoils::GetVSCoilPLFFPLR(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
+                HPWH.Capacity = VariableSpeedCoils::GetCoilCapacity(state, HPWH.DXCoilNum);
+                HPWH.DXCoilAirInletNode = VariableSpeedCoils::GetCoilAirInletNode(state, HPWH.DXCoilNum);
+                HPWH.DXCoilPLFFPLR = VariableSpeedCoils::GetCoilPLFFPLR(state, HPWH.DXCoilNum);
             }
             //         check the range of condenser pump power to be <= 5 gpm/ton, will be checked in the coil object
         }
@@ -1692,53 +1631,53 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         }
 
         // On Cycle Parasitic Electric Load
-        HPWH.OnCycParaLoad = hpwhNumeric[6 + nNumericOffset];
+        HPWH.OnCycParaLoad = rNumericArgs(6 + nNumericOffset);
         if (HPWH.OnCycParaLoad < 0.0) {
-            ShowSevereError(state, format("{}=\"{}\",", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            ShowSevereError(state, format("{}=\"{}\",", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state,
                               format("{} must be >= 0. {}{}",
-                                     hpwhNumericFieldNames[6 + nNumericOffset],
-                                     hpwhNumericFieldNames[6 + nNumericOffset],
-                                     format(" = {:.2T}", hpwhNumeric[6 + nNumericOffset])));
+                                     cNumericFieldNames(6 + nNumericOffset),
+                                     cNumericFieldNames(6 + nNumericOffset),
+                                     format(" = {:.2T}", rNumericArgs(6 + nNumericOffset))));
             ErrorsFound = true;
         }
 
         // Off Cycle Parasitic Electric Load
-        HPWH.OffCycParaLoad = hpwhNumeric[7 + nNumericOffset];
+        HPWH.OffCycParaLoad = rNumericArgs(7 + nNumericOffset);
         if (HPWH.OffCycParaLoad < 0.0) {
-            ShowSevereError(state, format("{}=\"{}\",", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            ShowSevereError(state, format("{}=\"{}\",", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state,
                               format("{} must be >= 0. {}{}",
-                                     hpwhNumericFieldNames[7 + nNumericOffset],
-                                     hpwhNumericFieldNames[2 + nNumericOffset],
-                                     format(" = {:.2T}", hpwhNumeric[7 + nNumericOffset])));
+                                     cNumericFieldNames(7 + nNumericOffset),
+                                     cNumericFieldNames(2 + nNumericOffset),
+                                     format(" = {:.2T}", rNumericArgs(7 + nNumericOffset))));
             ErrorsFound = true;
         }
 
         // Parasitic Heat Rejection Location
-        if (Util::SameString(hpwhAlpha[25 + nAlphaOffset], "Zone")) {
+        if (Util::SameString(cAlphaArgs(25 + nAlphaOffset), "Zone")) {
             HPWH.ParasiticTempIndicator = WTTAmbientTemp::TempZone;
             if (HPWH.InletAirConfiguration == WTTAmbientTemp::OutsideAir || HPWH.InletAirConfiguration == WTTAmbientTemp::Schedule) {
-                ShowSevereError(state, format("{}=\"{}\",", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                ShowContinueError(state, format("{} must be ZoneAirOnly or ZoneAndOutdoorAir", hpwhAlphaFieldNames[25 + nAlphaOffset]));
+                ShowSevereError(state, format("{}=\"{}\",", cCurrentModuleObject, HPWH.Name));
+                ShowContinueError(state, format("{} must be ZoneAirOnly or ZoneAndOutdoorAir", cAlphaFieldNames(25 + nAlphaOffset)));
                 ShowContinueError(state, " when parasitic heat rejection location equals Zone.");
                 ErrorsFound = true;
             }
-        } else if (Util::SameString(hpwhAlpha[25 + nAlphaOffset], "Outdoors")) {
+        } else if (Util::SameString(cAlphaArgs(25 + nAlphaOffset), "Outdoors")) {
             HPWH.ParasiticTempIndicator = WTTAmbientTemp::OutsideAir;
         } else {
-            ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state, " parasitic heat rejection location must be either Zone or Outdoors.");
             ErrorsFound = true;
         }
 
         // Inlet Air Mixer Node
         // get mixer/splitter nodes only when Inlet Air Configuration is ZoneAndOutdoorAir
-        if (!hpwhAlphaBlank[26 + nAlphaOffset]) {
+        if (!lAlphaFieldBlanks(26 + nAlphaOffset)) {
             // For the inlet air mixer node, NodeConnectionType is outlet from the HPWH inlet air node
             if (HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
                 HPWH.InletAirMixerNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             hpwhAlpha[26 + nAlphaOffset],
+                                                                             cAlphaArgs(26 + nAlphaOffset),
                                                                              ErrorsFound,
                                                                              objType,
                                                                              HPWH.Name + "-INLET AIR MIXER",
@@ -1747,23 +1686,23 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                              NodeInputManager::CompFluidStream::Primary,
                                                                              DataLoopNode::ObjectIsNotParent);
             } else {
-                ShowWarningError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowWarningError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state,
                                   "Inlet air mixer node name specified but only required when Inlet Air Configuration is selected as "
                                   "Zone and OutdoorAir. Node name disregarded and simulation continues.");
             }
-        } else if (hpwhAlphaBlank[26 + nAlphaOffset] && HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
-            ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+        } else if (lAlphaFieldBlanks(26 + nAlphaOffset) && HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
+            ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state, "Inlet air mixer node name required when Inlet Air Configuration is selected as ZoneAndOutdoorAir.");
             ErrorsFound = true;
         }
 
         // Outlet Air Splitter Node
-        if (!hpwhAlphaBlank[27 + nAlphaOffset]) {
+        if (!lAlphaFieldBlanks(27 + nAlphaOffset)) {
             //  For the outlet air splitter node, NodeConnectionType is inlet to the HPWH outlet air node
             if (HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
                 HPWH.OutletAirSplitterNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                 hpwhAlpha[27 + nAlphaOffset],
+                                                                                 cAlphaArgs(27 + nAlphaOffset),
                                                                                  ErrorsFound,
                                                                                  objType,
                                                                                  HPWH.Name + "-OUTLET AIR SPLITTER",
@@ -1772,13 +1711,13 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                                  NodeInputManager::CompFluidStream::Primary,
                                                                                  DataLoopNode::ObjectIsNotParent);
             } else {
-                ShowWarningError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowWarningError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state,
                                   "Outlet air splitter node name specified but only required when Inlet Air Configuration is selected as "
                                   "ZoneAndOutdoorAir. Node name disregarded and simulation continues.");
             }
-        } else if (hpwhAlphaBlank[27 + nAlphaOffset] && HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
-            ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+        } else if (lAlphaFieldBlanks(27 + nAlphaOffset) && HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
+            ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state, "Outlet air splitter node name required when Inlet Air Configuration is selected as ZoneAndOutdoorAir.");
             ErrorsFound = true;
         }
@@ -1788,7 +1727,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             // when mixer/splitter nodes are used the HPWH's inlet/outlet node are set up as DataLoopNode::ObjectIsNotParent
 
             HPWH.HeatPumpAirInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                            hpwhAlpha[7 + nAlphaOffset],
+                                                                            cAlphaArgs(7 + nAlphaOffset),
                                                                             ErrorsFound,
                                                                             objType,
                                                                             HPWH.Name + "-INLET AIR MIXER",
@@ -1798,7 +1737,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                             DataLoopNode::ObjectIsNotParent);
 
             HPWH.HeatPumpAirOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                             hpwhAlpha[8 + nAlphaOffset],
+                                                                             cAlphaArgs(8 + nAlphaOffset),
                                                                              ErrorsFound,
                                                                              objType,
                                                                              HPWH.Name + "-OUTLET AIR SPLITTER",
@@ -1808,7 +1747,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                              DataLoopNode::ObjectIsNotParent);
 
             HPWH.OutsideAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                      hpwhAlpha[9 + nAlphaOffset],
+                                                                      cAlphaArgs(9 + nAlphaOffset),
                                                                       ErrorsFound,
                                                                       objType,
                                                                       HPWH.Name,
@@ -1816,20 +1755,20 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                       DataLoopNode::ConnectionType::OutsideAirReference,
                                                                       NodeInputManager::CompFluidStream::Primary,
                                                                       DataLoopNode::ObjectIsParent);
-            if (!hpwhAlpha[9 + nAlphaOffset].empty()) {
+            if (!cAlphaArgs(9 + nAlphaOffset).empty()) {
                 bool Okay;
                 OutAirNodeManager::CheckAndAddAirNodeNumber(state, HPWH.OutsideAirNode, Okay);
                 if (!Okay) {
                     ShowWarningError(state,
                                      format("{}=\"{}\": Adding outdoor air node={}",
-                                            state.dataIPShortCut->cCurrentModuleObject,
+                                            cCurrentModuleObject,
                                             HPWH.Name,
-                                            hpwhAlpha[9 + nAlphaOffset]));
+                                            cAlphaArgs(9 + nAlphaOffset)));
                 }
             }
 
             HPWH.ExhaustAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                      hpwhAlpha[10 + nAlphaOffset],
+                                                                      cAlphaArgs(10 + nAlphaOffset),
                                                                       ErrorsFound,
                                                                       objType,
                                                                       HPWH.Name,
@@ -1844,7 +1783,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                 // for scheduled HPWH's the inlet node is not on any branch or parent object, make it an outlet node
                 // to avoid node connection errors
                 HPWH.HeatPumpAirInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                hpwhAlpha[7 + nAlphaOffset],
+                                                                                cAlphaArgs(7 + nAlphaOffset),
                                                                                 ErrorsFound,
                                                                                 objType,
                                                                                 HPWH.Name,
@@ -1854,7 +1793,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                                 DataLoopNode::ObjectIsParent);
 
                 HPWH.HeatPumpAirOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                 hpwhAlpha[8 + nAlphaOffset],
+                                                                                 cAlphaArgs(8 + nAlphaOffset),
                                                                                  ErrorsFound,
                                                                                  objType,
                                                                                  HPWH.Name,
@@ -1866,7 +1805,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             } else { // HPWH is connected to a zone with no mixer/splitter nodes
                 if (HPWH.InletAirConfiguration == WTTAmbientTemp::TempZone) {
                     HPWH.HeatPumpAirInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                    hpwhAlpha[7 + nAlphaOffset],
+                                                                                    cAlphaArgs(7 + nAlphaOffset),
                                                                                     ErrorsFound,
                                                                                     objType,
                                                                                     HPWH.Name,
@@ -1876,7 +1815,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                                     DataLoopNode::ObjectIsParent);
 
                     HPWH.HeatPumpAirOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                     hpwhAlpha[8 + nAlphaOffset],
+                                                                                     cAlphaArgs(8 + nAlphaOffset),
                                                                                      ErrorsFound,
                                                                                      objType,
                                                                                      HPWH.Name,
@@ -1886,7 +1825,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                                      DataLoopNode::ObjectIsParent);
                 } else { // HPWH is located outdoors
                     HPWH.OutsideAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                              hpwhAlpha[9 + nAlphaOffset],
+                                                                              cAlphaArgs(9 + nAlphaOffset),
                                                                               ErrorsFound,
                                                                               objType,
                                                                               HPWH.Name,
@@ -1894,20 +1833,20 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                                                                               DataLoopNode::ConnectionType::OutsideAirReference,
                                                                               NodeInputManager::CompFluidStream::Primary,
                                                                               DataLoopNode::ObjectIsParent);
-                    if (!hpwhAlphaBlank[9 + nAlphaOffset]) {
+                    if (!lAlphaFieldBlanks(9 + nAlphaOffset)) {
                         bool Okay;
                         OutAirNodeManager::CheckAndAddAirNodeNumber(state, HPWH.OutsideAirNode, Okay);
                         if (!Okay) {
                             ShowWarningError(state,
                                              format("{}=\"{}\": Adding outdoor air node ={}",
-                                                    state.dataIPShortCut->cCurrentModuleObject,
+                                                    cCurrentModuleObject,
                                                     HPWH.Name,
-                                                    hpwhAlpha[9 + nAlphaOffset]));
+                                                    cAlphaArgs(9 + nAlphaOffset)));
                         }
                     }
 
                     HPWH.ExhaustAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                              hpwhAlpha[10 + nAlphaOffset],
+                                                                              cAlphaArgs(10 + nAlphaOffset),
                                                                               ErrorsFound,
                                                                               objType,
                                                                               HPWH.Name,
@@ -1921,31 +1860,31 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         // check that required node names are present
         if (HPWH.InletAirConfiguration == WTTAmbientTemp::Schedule || HPWH.InletAirConfiguration == WTTAmbientTemp::TempZone) {
             if (HPWH.HeatPumpAirInletNode == 0 || HPWH.HeatPumpAirOutletNode == 0) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                ShowContinueError(state, format("When {}=\"{}\".", hpwhAlphaFieldNames[6 + nAlphaOffset], hpwhAlpha[6 + nAlphaOffset]));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
+                ShowContinueError(state, format("When {}=\"{}\".", cAlphaFieldNames(6 + nAlphaOffset), cAlphaArgs(6 + nAlphaOffset)));
                 ShowContinueError(
-                    state, format("{} and {} must be specified.", hpwhAlphaFieldNames[7 + nAlphaOffset], hpwhAlphaFieldNames[8 + nAlphaOffset]));
+                    state, format("{} and {} must be specified.", cAlphaFieldNames(7 + nAlphaOffset), cAlphaFieldNames(8 + nAlphaOffset)));
                 ErrorsFound = true;
             }
         } else if (HPWH.InletAirConfiguration == WTTAmbientTemp::OutsideAir) {
             if (HPWH.OutsideAirNode == 0 || HPWH.ExhaustAirNode == 0) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                ShowContinueError(state, format("When {}=\"{}\".", hpwhAlphaFieldNames[6 + nAlphaOffset], hpwhAlpha[6 + nAlphaOffset]));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
+                ShowContinueError(state, format("When {}=\"{}\".", cAlphaFieldNames(6 + nAlphaOffset), cAlphaArgs(6 + nAlphaOffset)));
                 ShowContinueError(
-                    state, format("{} and {} must be specified.", hpwhAlphaFieldNames[9 + nAlphaOffset], hpwhAlphaFieldNames[10 + nAlphaOffset]));
+                    state, format("{} and {} must be specified.", cAlphaFieldNames(9 + nAlphaOffset), cAlphaFieldNames(10 + nAlphaOffset)));
                 ErrorsFound = true;
             }
         } else if (HPWH.InletAirMixerNode > 0 && HPWH.OutletAirSplitterNode > 0 && HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
             if (HPWH.HeatPumpAirInletNode == 0 || HPWH.HeatPumpAirOutletNode == 0 || HPWH.OutsideAirNode == 0 || HPWH.ExhaustAirNode == 0) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
-                ShowContinueError(state, format("When {}=\"{}\".", hpwhAlphaFieldNames[6 + nAlphaOffset], hpwhAlpha[6 + nAlphaOffset]));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
+                ShowContinueError(state, format("When {}=\"{}\".", cAlphaFieldNames(6 + nAlphaOffset), cAlphaArgs(6 + nAlphaOffset)));
                 if (HPWH.HeatPumpAirInletNode == 0 || HPWH.HeatPumpAirOutletNode == 0) {
                     ShowContinueError(
-                        state, format("{} and {} must be specified.", hpwhAlphaFieldNames[7 + nAlphaOffset], hpwhAlphaFieldNames[8 + nAlphaOffset]));
+                        state, format("{} and {} must be specified.", cAlphaFieldNames(7 + nAlphaOffset), cAlphaFieldNames(8 + nAlphaOffset)));
                 }
                 if (HPWH.OutsideAirNode == 0 || HPWH.ExhaustAirNode == 0) {
                     ShowContinueError(
-                        state, format("{} and {} must be specified.", hpwhAlphaFieldNames[9 + nAlphaOffset], hpwhAlphaFieldNames[10 + nAlphaOffset]));
+                        state, format("{} and {} must be specified.", cAlphaFieldNames(9 + nAlphaOffset), cAlphaFieldNames(10 + nAlphaOffset)));
                 }
                 ErrorsFound = true;
             }
@@ -1969,26 +1908,26 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                         FoundInletNode = true;
                     }
                     if (!FoundInletNode) {
-                        ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                        ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                         ShowContinueError(state,
-                                          format("The HPWH's air inlet node name = {} was not properly specified ", hpwhAlpha[7 + nAlphaOffset]));
+                                          format("The HPWH's air inlet node name = {} was not properly specified ", cAlphaArgs(7 + nAlphaOffset)));
                         ShowContinueError(
                             state,
-                            format("as an exhaust air node for zone = {} in a ZoneHVAC:EquipmentConnections object.", hpwhAlpha[13 + nAlphaOffset]));
+                            format("as an exhaust air node for zone = {} in a ZoneHVAC:EquipmentConnections object.", cAlphaArgs(13 + nAlphaOffset)));
                         ErrorsFound = true;
                     }
                     if (!FoundOutletNode) {
-                        ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                        ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                         ShowContinueError(state,
-                                          format("The HPWH's air outlet node name = {} was not properly specified ", hpwhAlpha[8 + nAlphaOffset]));
+                                          format("The HPWH's air outlet node name = {} was not properly specified ", cAlphaArgs(8 + nAlphaOffset)));
                         ShowContinueError(
                             state,
-                            format("as an inlet air node for zone = {} in a ZoneHVAC:EquipmentConnections object.", hpwhAlpha[13 + nAlphaOffset]));
+                            format("as an inlet air node for zone = {} in a ZoneHVAC:EquipmentConnections object.", cAlphaArgs(13 + nAlphaOffset)));
                         ErrorsFound = true;
                     }
                 }
             } else {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state,
                                   "Heat pump water heater air inlet node name and air outlet node name must be listed in a "
                                   "ZoneHVAC:EquipmentConnections object when Inlet Air Configuration is equal to ZoneAirOnly or "
@@ -1999,17 +1938,17 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
 
         // only get the inlet air mixer schedule if the inlet air configuration is zone and outdoor air
         if (HPWH.InletAirConfiguration == WTTAmbientTemp::ZoneAndOA) {
-            if (hpwhAlphaBlank[28 + nAlphaOffset]) {
-                ShowSevereEmptyField(state, eoh, hpwhAlphaFieldNames[28 + nAlphaOffset]);
+            if (lAlphaFieldBlanks(28 + nAlphaOffset)) {
+                ShowSevereEmptyField(state, eoh, cAlphaFieldNames(28 + nAlphaOffset));
                 ErrorsFound = true;
                 //           set outlet air splitter schedule index equal to inlet air mixer schedule index
                 //           (place holder for when zone pressurization/depressurization is allowed and different schedules can be used)
-            } else if ((HPWH.inletAirMixerSched = HPWH.outletAirSplitterSched = Sched::GetSchedule(state, hpwhAlpha[28 + nAlphaOffset])) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, hpwhAlphaFieldNames[28 + nAlphaOffset], hpwhAlpha[28 + nAlphaOffset]);
+            } else if ((HPWH.inletAirMixerSched = HPWH.outletAirSplitterSched = Sched::GetSchedule(state, cAlphaArgs(28 + nAlphaOffset))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, cAlphaFieldNames(28 + nAlphaOffset), cAlphaArgs(28 + nAlphaOffset));
                 ErrorsFound = true;
             } else if (!HPWH.inletAirMixerSched->checkMinMaxVals(state, Clusive::In, 0.0, Clusive::In, 1.0)) {
                 Sched::ShowSevereBadMinMax(
-                    state, eoh, hpwhAlphaFieldNames[28 + nAlphaOffset], hpwhAlpha[28 + nAlphaOffset], Clusive::In, 0.0, Clusive::In, 1.0);
+                    state, eoh, cAlphaFieldNames(28 + nAlphaOffset), cAlphaArgs(28 + nAlphaOffset), Clusive::In, 0.0, Clusive::In, 1.0);
                 ErrorsFound = true;
             }
         }
@@ -2027,12 +1966,12 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
             // set fan outlet node variable for use in setting Node(FanOutletNode)%MassFlowRateMax for fan object
             if (bIsVScoil) {
                 if (HPWH.bIsIHP) {
-                    HPWH.FanOutletNode = IntegratedHeatPump::GetDWHCoilInletNodeIHP(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
+                    HPWH.FanOutletNode = IntegratedHeatPump::GetIHPDWHCoilAirInletNode(state, HPWH.DXCoilNum);
                 } else {
-                    HPWH.FanOutletNode = VariableSpeedCoils::GetCoilInletNodeVariableSpeed(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
+                    HPWH.FanOutletNode = VariableSpeedCoils::GetCoilAirInletNode(state, HPWH.DXCoilNum);
                 }
             } else {
-                HPWH.FanOutletNode = state.dataDXCoils->DXCoil(HPWH.DXCoilNum).AirInNode;
+                HPWH.FanOutletNode = DXCoils::GetCoilAirInletNode(state, HPWH.DXCoilNum);
             }
         }
 
@@ -2040,7 +1979,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         int FanOutletNodeNum = state.dataFans->fans(HPWH.FanNum)->outletNodeNum;
 
         if (FanOutletNodeNum != HPWH.FanOutletNode) {
-            ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state, "Heat pump water heater fan outlet node name does not match next connected component.");
             if (FanOutletNodeNum != 0) {
                 ShowContinueError(state, format("Fan outlet node name = {}", state.dataLoopNodes->NodeID(FanOutletNodeNum)));
@@ -2064,7 +2003,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         }
         if (HPWH.fanPlace == HVAC::FanPlace::BlowThru) {
             if (FanInletNodeNum != HPWHFanInletNodeNum) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state, "Heat pump water heater fan inlet node name does not match previous connected component.");
                 if (FanOutletNodeNum != 0) {
                     ShowContinueError(state, format("Fan inlet node name = {}", state.dataLoopNodes->NodeID(FanInletNodeNum)));
@@ -2079,17 +2018,18 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         int DXCoilAirOutletNodeNum(0);
         if ((HPWH.DXCoilNum > 0) && (bIsVScoil)) {
             if (HPWH.bIsIHP) {
-                DXCoilAirOutletNodeNum = IntegratedHeatPump::GetDWHCoilOutletNodeIHP(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
+                DXCoilAirOutletNodeNum = IntegratedHeatPump::GetIHPDWHCoilAirOutletNode(state, HPWH.DXCoilNum);
             } else {
-                DXCoilAirOutletNodeNum = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(state, HPWH.DXCoilType, HPWH.DXCoilName, DXCoilErrFlag);
+                DXCoilAirOutletNodeNum = VariableSpeedCoils::GetCoilAirOutletNode(state, HPWH.DXCoilNum);
             }
 
         } else if (HPWH.DXCoilNum > 0) {
             DXCoilAirOutletNodeNum = state.dataDXCoils->DXCoil(HPWH.DXCoilNum).AirOutNode;
         }
+        
         if (HPWH.fanPlace == HVAC::FanPlace::DrawThru) {
             if (FanInletNodeNum != DXCoilAirOutletNodeNum) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state, "Heat pump water heater fan inlet node name does not match previous connected component.");
                 if (FanInletNodeNum != 0) {
                     ShowContinueError(state, format("Fan inlet node name = {}", state.dataLoopNodes->NodeID(FanInletNodeNum)));
@@ -2111,7 +2051,7 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
                 }
             }
             if (DXCoilAirOutletNodeNum != HPWHCoilOutletNodeNum) {
-                ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
                 ShowContinueError(state, "Heat pump water heater coil outlet node name does not match next connected component.");
                 if (DXCoilAirOutletNodeNum != 0) {
                     ShowContinueError(state, format("Coil outlet node name = {}", state.dataLoopNodes->NodeID(DXCoilAirOutletNodeNum)));
@@ -2130,52 +2070,52 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
 
         if (HPWH.fanPlace == HVAC::FanPlace::BlowThru) {
             if (HPWH.InletAirMixerNode > 0) {
-                HPWH.FanInletNode_str = hpwhAlpha[26 + nAlphaOffset];
+                HPWH.FanInletNode_str = cAlphaArgs(26 + nAlphaOffset);
                 HPWH.FanOutletNode_str = "UNDEFINED";
             } else {
                 if (HPWH.OutsideAirNode == 0) {
-                    HPWH.FanInletNode_str = hpwhAlpha[7 + nAlphaOffset];
+                    HPWH.FanInletNode_str = cAlphaArgs(7 + nAlphaOffset);
                     HPWH.FanOutletNode_str = "UNDEFINED";
                 } else {
-                    HPWH.FanInletNode_str = hpwhAlpha[9 + nAlphaOffset];
+                    HPWH.FanInletNode_str = cAlphaArgs(9 + nAlphaOffset);
                     HPWH.FanOutletNode_str = "UNDEFINED";
                 }
             }
             if (HPWH.OutletAirSplitterNode > 0) {
                 HPWH.CoilInletNode_str = "UNDEFINED";
-                HPWH.CoilOutletNode_str = hpwhAlpha[27 + nAlphaOffset];
+                HPWH.CoilOutletNode_str = cAlphaArgs(27 + nAlphaOffset);
             } else {
                 if (HPWH.OutsideAirNode == 0) {
                     HPWH.CoilInletNode_str = "UNDEFINED";
-                    HPWH.CoilOutletNode_str = hpwhAlpha[8 + nAlphaOffset];
+                    HPWH.CoilOutletNode_str = cAlphaArgs(8 + nAlphaOffset);
                 } else {
                     HPWH.CoilInletNode_str = "UNDEFINED";
-                    HPWH.CoilOutletNode_str = hpwhAlpha[10 + nAlphaOffset];
+                    HPWH.CoilOutletNode_str = cAlphaArgs(10 + nAlphaOffset);
                 }
             }
         } else {
             if (HPWH.InletAirMixerNode > 0) {
-                HPWH.CoilInletNode_str = hpwhAlpha[26 + nAlphaOffset];
+                HPWH.CoilInletNode_str = cAlphaArgs(26 + nAlphaOffset);
                 HPWH.CoilOutletNode_str = "UNDEFINED";
             } else {
                 if (HPWH.OutsideAirNode == 0) {
-                    HPWH.CoilInletNode_str = hpwhAlpha[7 + nAlphaOffset];
+                    HPWH.CoilInletNode_str = cAlphaArgs(7 + nAlphaOffset);
                     HPWH.CoilOutletNode_str = "UNDEFINED";
                 } else {
-                    HPWH.CoilInletNode_str = hpwhAlpha[9 + nAlphaOffset];
+                    HPWH.CoilInletNode_str = cAlphaArgs(9 + nAlphaOffset);
                     HPWH.CoilOutletNode_str = "UNDEFINED";
                 }
             }
             if (HPWH.OutletAirSplitterNode > 0) {
                 HPWH.FanInletNode_str = "UNDEFINED";
-                HPWH.FanOutletNode_str = hpwhAlpha[27 + nAlphaOffset];
+                HPWH.FanOutletNode_str = cAlphaArgs(27 + nAlphaOffset);
             } else {
                 if (HPWH.OutsideAirNode == 0) {
                     HPWH.FanInletNode_str = "UNDEFINED";
-                    HPWH.FanOutletNode_str = hpwhAlpha[8 + nAlphaOffset];
+                    HPWH.FanOutletNode_str = cAlphaArgs(8 + nAlphaOffset);
                 } else {
                     HPWH.FanInletNode_str = "UNDEFINED";
-                    HPWH.FanOutletNode_str = hpwhAlpha[10 + nAlphaOffset];
+                    HPWH.FanOutletNode_str = cAlphaArgs(10 + nAlphaOffset);
                 }
             }
         }
@@ -2183,41 +2123,41 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
         // set up comp set for air side nodes (can be blow thru or draw thru, may or may not have damper nodes)
         if (HPWH.bIsIHP) {
             BranchNodeConnections::SetUpCompSets(
-                state, HPWH.Type, HPWH.Name, HPWH.DXCoilType, HPWH.DXCoilName + " Outdoor Coil", HPWH.CoilInletNode_str, HPWH.CoilOutletNode_str);
+                state, HPWH.Type, HPWH.Name, HVAC::coilTypeNames[(int)HPWH.DXCoilType], HPWH.DXCoilName + " Outdoor Coil", HPWH.CoilInletNode_str, HPWH.CoilOutletNode_str);
         } else {
             BranchNodeConnections::SetUpCompSets(
-                state, HPWH.Type, HPWH.Name, HPWH.DXCoilType, HPWH.DXCoilName, HPWH.CoilInletNode_str, HPWH.CoilOutletNode_str);
+                 state, HPWH.Type, HPWH.Name, HVAC::coilTypeNames[(int)HPWH.DXCoilType], HPWH.DXCoilName, HPWH.CoilInletNode_str, HPWH.CoilOutletNode_str);
         }
 
         BranchNodeConnections::SetUpCompSets(
             state, HPWH.Type, HPWH.Name, HVAC::fanTypeNames[(int)HPWH.fanType], HPWH.FanName, HPWH.FanInletNode_str, HPWH.FanOutletNode_str);
 
         // Control Logic Flag
-        std::string CtrlLogicFlag = hpwhAlphaBlank[29 + nAlphaOffset] ? "SIMULTANEOUS" : hpwhAlpha[29 + nAlphaOffset];
+        std::string CtrlLogicFlag = lAlphaFieldBlanks(29 + nAlphaOffset) ? "SIMULTANEOUS" : cAlphaArgs(29 + nAlphaOffset);
         if (Util::SameString(CtrlLogicFlag, "SIMULTANEOUS")) {
             HPWH.AllowHeatingElementAndHeatPumpToRunAtSameTime = true;
         } else if (Util::SameString(CtrlLogicFlag, "MUTUALLYEXCLUSIVE")) {
             HPWH.AllowHeatingElementAndHeatPumpToRunAtSameTime = false;
         } else {
-            ShowSevereError(state, format("{}=\"{}\":", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+            ShowSevereError(state, format("{}=\"{}\":", cCurrentModuleObject, HPWH.Name));
             ShowContinueError(state, format("{} is not a valid value for field Tank Element Control Logic.", CtrlLogicFlag));
             ErrorsFound = true;
         }
 
         // Control Sensor 1 Location In Stratified Tank
-        if (!hpwhNumericBlank[8 + nNumericOffset]) {
-            HPWH.ControlSensor1Height = hpwhNumeric[8 + nNumericOffset];
+        if (!lNumericFieldBlanks(8 + nNumericOffset)) {
+            HPWH.ControlSensor1Height = rNumericArgs(8 + nNumericOffset);
         } else {
             // use heater1 location, which we don't know right now
             HPWH.ControlSensor1Height = -1.0;
         }
 
         // Control Sensor 1 Weight
-        HPWH.ControlSensor1Weight = hpwhNumericBlank[9 + nNumericOffset] ? 1.0 : hpwhNumeric[9 + nNumericOffset];
+        HPWH.ControlSensor1Weight = lNumericFieldBlanks(9 + nNumericOffset) ? 1.0 : rNumericArgs(9 + nNumericOffset);
 
         // Control Sensor 2 Location In Stratified Tank
-        if (!hpwhNumericBlank[10 + nNumericOffset]) {
-            HPWH.ControlSensor2Height = hpwhNumeric[10 + nNumericOffset];
+        if (!lNumericFieldBlanks(10 + nNumericOffset)) {
+            HPWH.ControlSensor2Height = rNumericArgs(10 + nNumericOffset);
         } else {
             HPWH.ControlSensor2Height = -1.0;
         }
@@ -2231,39 +2171,42 @@ bool getHPWaterHeaterInput(EnergyPlusData &state)
 
 bool getWaterHeaterMixedInputs(EnergyPlusData &state)
 {
-    bool ErrorsFound = false;
-    state.dataIPShortCut->cCurrentModuleObject = cMixedWHModuleObj;
     static constexpr std::string_view routineName = "getWaterHeaterMixedInputs";
+    
+    bool ErrorsFound = false;
+    auto &s_ipsc = state.dataIPShortCut;
+    
+    s_ipsc->cCurrentModuleObject = cMixedWHModuleObj;
 
     for (int WaterThermalTankNum = 1; WaterThermalTankNum <= state.dataWaterThermalTanks->numWaterHeaterMixed; ++WaterThermalTankNum) {
         int NumAlphas;
         int NumNums;
         int IOStat;
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 state.dataIPShortCut->cCurrentModuleObject,
+                                                                 s_ipsc->cCurrentModuleObject,
                                                                  WaterThermalTankNum,
-                                                                 state.dataIPShortCut->cAlphaArgs,
+                                                                 s_ipsc->cAlphaArgs,
                                                                  NumAlphas,
-                                                                 state.dataIPShortCut->rNumericArgs,
+                                                                 s_ipsc->rNumericArgs,
                                                                  NumNums,
                                                                  IOStat,
-                                                                 state.dataIPShortCut->lNumericFieldBlanks,
-                                                                 state.dataIPShortCut->lAlphaFieldBlanks,
-                                                                 state.dataIPShortCut->cAlphaFieldNames,
-                                                                 state.dataIPShortCut->cNumericFieldNames);
+                                                                 s_ipsc->lNumericFieldBlanks,
+                                                                 s_ipsc->lAlphaFieldBlanks,
+                                                                 s_ipsc->cAlphaFieldNames,
+                                                                 s_ipsc->cNumericFieldNames);
 
-        ErrorObjectHeader eoh{routineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)};
+        ErrorObjectHeader eoh{routineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)};
         GlobalNames::VerifyUniqueInterObjectName(state,
                                                  state.dataWaterThermalTanks->UniqueWaterThermalTankNames,
-                                                 state.dataIPShortCut->cAlphaArgs(1),
-                                                 state.dataIPShortCut->cCurrentModuleObject,
-                                                 state.dataIPShortCut->cAlphaFieldNames(1),
+                                                 s_ipsc->cAlphaArgs(1),
+                                                 s_ipsc->cCurrentModuleObject,
+                                                 s_ipsc->cAlphaFieldNames(1),
                                                  ErrorsFound);
 
         auto &Tank = state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum);
 
-        Tank.Name = state.dataIPShortCut->cAlphaArgs(1);
-        Tank.Type = state.dataIPShortCut->cCurrentModuleObject;
+        Tank.Name = s_ipsc->cAlphaArgs(1);
+        Tank.Type = s_ipsc->cCurrentModuleObject;
         Tank.WaterThermalTankType = DataPlant::PlantEquipmentType::WtrHeaterMixed;
 
         if ((Tank.water = Fluid::GetWater(state)) == nullptr) {
@@ -2278,56 +2221,56 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
         // A user field will be added in a later release
         Tank.EndUseSubcategoryName = "Water Heater";
 
-        Tank.Volume = state.dataIPShortCut->rNumericArgs(1);
+        Tank.Volume = s_ipsc->rNumericArgs(1);
         if (Tank.Volume == DataSizing::AutoSize) {
             Tank.VolumeWasAutoSized = true;
         }
-        if (state.dataIPShortCut->rNumericArgs(1) == 0.0) {
+        if (s_ipsc->rNumericArgs(1) == 0.0) {
             // Set volume to a really small number to simulate a tankless/instantaneous water heater
             Tank.Volume = 0.000001; // = 1 cm3
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(2)) {
-            ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(2));
+        if (s_ipsc->lAlphaFieldBlanks(2)) {
+            ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(2));
             ErrorsFound = true;
-        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(2))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(2), state.dataIPShortCut->cAlphaArgs(2));
+        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(2))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(2), s_ipsc->cAlphaArgs(2));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(2) > 0.0001) {
-            Tank.DeadBandDeltaTemp = state.dataIPShortCut->rNumericArgs(2);
+        if (s_ipsc->rNumericArgs(2) > 0.0001) {
+            Tank.DeadBandDeltaTemp = s_ipsc->rNumericArgs(2);
         } else {
             // Default to very small number (however it can't be TINY or it will break the algorithm)
             Tank.DeadBandDeltaTemp = 0.5;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(3) > 0.0) {
-            Tank.TankTempLimit = state.dataIPShortCut->rNumericArgs(3);
+        if (s_ipsc->rNumericArgs(3) > 0.0) {
+            Tank.TankTempLimit = s_ipsc->rNumericArgs(3);
         } else {
             // Default to very large number
             // BG comment why a large number here why not boilng point of water?
             Tank.TankTempLimit = 100.0; // 1.0E9
         }
 
-        Tank.MaxCapacity = state.dataIPShortCut->rNumericArgs(4);
+        Tank.MaxCapacity = s_ipsc->rNumericArgs(4);
         if (Tank.MaxCapacity == DataSizing::AutoSize) {
             Tank.MaxCapacityWasAutoSized = true;
         }
 
-        if ((state.dataIPShortCut->rNumericArgs(5) > Tank.MaxCapacity) && (!Tank.MaxCapacityWasAutoSized)) {
+        if ((s_ipsc->rNumericArgs(5) > Tank.MaxCapacity) && (!Tank.MaxCapacityWasAutoSized)) {
             ShowSevereError(state,
                             format("{} = {}:  Heater Minimum Capacity cannot be greater than Heater Maximum Capacity",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
             ErrorsFound = true;
         } else {
-            Tank.MinCapacity = state.dataIPShortCut->rNumericArgs(5);
+            Tank.MinCapacity = s_ipsc->rNumericArgs(5);
         }
 
         // Validate Heater Control Type
         Tank.ControlType =
-            static_cast<HeaterControlMode>(getEnumValue(HeaterControlModeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(3))));
+            static_cast<HeaterControlMode>(getEnumValue(HeaterControlModeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(3))));
         switch (Tank.ControlType) {
         case HeaterControlMode::Cycle: {
             Tank.MinCapacity = Tank.MaxCapacity;
@@ -2344,27 +2287,27 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
         default: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Control Type entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(3)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(3)));
             ErrorsFound = true;
             break;
         }
         }
 
-        Tank.VolFlowRateMin = state.dataIPShortCut->rNumericArgs(6);
+        Tank.VolFlowRateMin = s_ipsc->rNumericArgs(6);
         Tank.VolFlowRateMin = max(0.0, Tank.VolFlowRateMin);
-        Tank.IgnitionDelay = state.dataIPShortCut->rNumericArgs(7); // Not yet implemented
+        Tank.IgnitionDelay = s_ipsc->rNumericArgs(7); // Not yet implemented
 
         // Validate Heater Fuel Type
-        Tank.FuelType = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, state.dataIPShortCut->cAlphaArgs(4)));
+        Tank.FuelType = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, s_ipsc->cAlphaArgs(4)));
         switch (Tank.FuelType) {
         case Constant::eFuel::Invalid: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Heater Fuel Type entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(4)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(4)));
             // Set to Electric to avoid errors when setting up output variables
             Tank.FuelType = Constant::eFuel::Electricity;
             ErrorsFound = true;
@@ -2374,32 +2317,32 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
             break;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(8) > 0.0) {
-            Tank.Efficiency = state.dataIPShortCut->rNumericArgs(8);
-            if (state.dataIPShortCut->rNumericArgs(8) > 1.0) {
+        if (s_ipsc->rNumericArgs(8) > 0.0) {
+            Tank.Efficiency = s_ipsc->rNumericArgs(8);
+            if (s_ipsc->rNumericArgs(8) > 1.0) {
                 ShowWarningError(state,
                                  fmt::format("{} = {}: {}={} should not typically be greater than 1.",
-                                             state.dataIPShortCut->cCurrentModuleObject,
-                                             state.dataIPShortCut->cAlphaArgs(1),
-                                             state.dataIPShortCut->cNumericFieldNames(8),
-                                             state.dataIPShortCut->rNumericArgs(8)));
+                                             s_ipsc->cCurrentModuleObject,
+                                             s_ipsc->cAlphaArgs(1),
+                                             s_ipsc->cNumericFieldNames(8),
+                                             s_ipsc->rNumericArgs(8)));
             }
         } else {
             ShowSevereError(state,
                             format("{} = {}:  Heater Thermal Efficiency must be greater than zero",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
             ErrorsFound = true;
         }
 
-        if (!state.dataIPShortCut->cAlphaArgs(5).empty()) {
-            Tank.PLFCurve = Curve::GetCurveIndex(state, state.dataIPShortCut->cAlphaArgs(5));
+        if (!s_ipsc->cAlphaArgs(5).empty()) {
+            Tank.PLFCurve = Curve::GetCurveIndex(state, s_ipsc->cAlphaArgs(5));
             if (Tank.PLFCurve == 0) {
                 ShowSevereError(state,
                                 format("{} = {}:  Part Load Factor curve not found = {}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(5)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(5)));
                 ErrorsFound = true;
             } else {
                 bool IsValid;
@@ -2409,8 +2352,8 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
                     ShowSevereError(
                         state,
                         format("{} = {}:  Part Load Factor curve failed to evaluate to greater than zero for all numbers in the domain of 0 to 1",
-                               state.dataIPShortCut->cCurrentModuleObject,
-                               state.dataIPShortCut->cAlphaArgs(1)));
+                               s_ipsc->cCurrentModuleObject,
+                               s_ipsc->cAlphaArgs(1)));
                     ErrorsFound = true;
                 }
 
@@ -2418,26 +2361,26 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
                                                      Tank.PLFCurve,                              // Curve index
                                                      {1},                                        // Valid dimensions
                                                      routineName,                                // Routine name
-                                                     state.dataIPShortCut->cCurrentModuleObject, // Object Type
+                                                     s_ipsc->cCurrentModuleObject, // Object Type
                                                      Tank.Name,                                  // Object Name
-                                                     state.dataIPShortCut->cAlphaFieldNames(5)); // Field Name
+                                                     s_ipsc->cAlphaFieldNames(5)); // Field Name
             }
         }
 
-        Tank.OffCycParaLoad = state.dataIPShortCut->rNumericArgs(9);
+        Tank.OffCycParaLoad = s_ipsc->rNumericArgs(9);
 
         // Validate Off-Cycle Parasitic Fuel Type
-        Tank.OffCycParaFuelType = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, state.dataIPShortCut->cAlphaArgs(6)));
+        Tank.OffCycParaFuelType = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, s_ipsc->cAlphaArgs(6)));
         switch (Tank.OffCycParaFuelType) {
         case Constant::eFuel::Invalid:
-            if (state.dataIPShortCut->cAlphaArgs(6).empty()) { // If blank, default to Fuel Type for heater
+            if (s_ipsc->cAlphaArgs(6).empty()) { // If blank, default to Fuel Type for heater
                 Tank.OffCycParaFuelType = Tank.FuelType;
             } else { // could have been an unsupported value
                 ShowSevereError(state,
                                 format("{} = {}:  Invalid Off-Cycle Parasitic Fuel Type entered={}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(6)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(6)));
                 // Set to Electric to avoid errors when setting up output variables
                 Tank.OffCycParaFuelType = Constant::eFuel::Electricity;
                 ErrorsFound = true;
@@ -2447,22 +2390,22 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
             break;
         }
 
-        Tank.OffCycParaFracToTank = state.dataIPShortCut->rNumericArgs(10);
+        Tank.OffCycParaFracToTank = s_ipsc->rNumericArgs(10);
 
-        Tank.OnCycParaLoad = state.dataIPShortCut->rNumericArgs(11);
+        Tank.OnCycParaLoad = s_ipsc->rNumericArgs(11);
 
         // Validate On-Cycle Parasitic Fuel Type
-        Tank.OnCycParaFuelType = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, state.dataIPShortCut->cAlphaArgs(7)));
+        Tank.OnCycParaFuelType = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, s_ipsc->cAlphaArgs(7)));
         switch (Tank.OnCycParaFuelType) {
         case Constant::eFuel::Invalid:
-            if (state.dataIPShortCut->cAlphaArgs(7).empty()) { // If blank, default to Fuel Type for heater
+            if (s_ipsc->cAlphaArgs(7).empty()) { // If blank, default to Fuel Type for heater
                 Tank.OnCycParaFuelType = Tank.FuelType;
             } else { // could have been an unsupported value
                 ShowSevereError(state,
                                 format("{} = {}:  Invalid On-Cycle Parasitic Fuel Type entered={}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(7)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(7)));
                 // Set to Electric to avoid errors when setting up output variables
                 Tank.OnCycParaFuelType = Constant::eFuel::Electricity;
                 ErrorsFound = true;
@@ -2472,55 +2415,55 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
             break;
         }
 
-        Tank.OnCycParaFracToTank = state.dataIPShortCut->rNumericArgs(12);
+        Tank.OnCycParaFracToTank = s_ipsc->rNumericArgs(12);
 
         Tank.AmbientTempIndicator =
-            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(8))));
+            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(8))));
         switch (Tank.AmbientTempIndicator) {
 
         case WTTAmbientTemp::Schedule: {
-            if (state.dataIPShortCut->lAlphaFieldBlanks(9)) {
-                ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(9));
+            if (s_ipsc->lAlphaFieldBlanks(9)) {
+                ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(9));
                 ErrorsFound = true;
-            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(9))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(9), state.dataIPShortCut->cAlphaArgs(9));
+            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(9))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(9), s_ipsc->cAlphaArgs(9));
                 ErrorsFound = true;
             }
         } break;
 
         case WTTAmbientTemp::TempZone: {
-            Tank.AmbientTempZone = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(10), state.dataHeatBal->Zone);
+            Tank.AmbientTempZone = Util::FindItemInList(s_ipsc->cAlphaArgs(10), state.dataHeatBal->Zone);
             if (Tank.AmbientTempZone == 0) {
                 ShowSevereError(state,
                                 format("{} = {}:  Ambient Temperature Zone not found = {}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(10)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(10)));
                 ErrorsFound = true;
             }
         } break;
 
         case WTTAmbientTemp::OutsideAir: {
             Tank.AmbientTempOutsideAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                 state.dataIPShortCut->cAlphaArgs(11),
+                                                                                 s_ipsc->cAlphaArgs(11),
                                                                                  ErrorsFound,
                                                                                  DataLoopNode::ConnectionObjectType::WaterHeaterMixed,
-                                                                                 state.dataIPShortCut->cAlphaArgs(1),
+                                                                                 s_ipsc->cAlphaArgs(1),
                                                                                  DataLoopNode::NodeFluidType::Air,
                                                                                  DataLoopNode::ConnectionType::OutsideAirReference,
                                                                                  NodeInputManager::CompFluidStream::Primary,
                                                                                  DataLoopNode::ObjectIsNotParent);
-            if (!state.dataIPShortCut->cAlphaArgs(11).empty()) {
+            if (!s_ipsc->cAlphaArgs(11).empty()) {
                 if (!OutAirNodeManager::CheckOutAirNodeNumber(state, Tank.AmbientTempOutsideAirNode)) {
                     ShowSevereError(state,
                                     format("{} = {}: Outdoor Air Node not on OutdoorAir:NodeList or OutdoorAir:Node",
-                                           state.dataIPShortCut->cCurrentModuleObject,
-                                           state.dataIPShortCut->cAlphaArgs(1)));
-                    ShowContinueError(state, format("...Referenced Node Name={}", state.dataIPShortCut->cAlphaArgs(11)));
+                                           s_ipsc->cCurrentModuleObject,
+                                           s_ipsc->cAlphaArgs(1)));
+                    ShowContinueError(state, format("...Referenced Node Name={}", s_ipsc->cAlphaArgs(11)));
                     ErrorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                ShowSevereError(state, format("{} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state, "An Ambient Outdoor Air Node name must be used when the Ambient Temperature Indicator is Outdoors.");
                 ErrorsFound = true;
             }
@@ -2530,72 +2473,72 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
         default: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Ambient Temperature Indicator entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(8)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(8)));
             ShowContinueError(state, " Valid entries are SCHEDULE, ZONE, and OUTDOORS.");
             ErrorsFound = true;
             break;
         }
         }
 
-        Tank.OffCycLossCoeff = state.dataIPShortCut->rNumericArgs(13);
-        Tank.OffCycLossFracToZone = state.dataIPShortCut->rNumericArgs(14);
+        Tank.OffCycLossCoeff = s_ipsc->rNumericArgs(13);
+        Tank.OffCycLossFracToZone = s_ipsc->rNumericArgs(14);
 
-        Tank.OnCycLossCoeff = state.dataIPShortCut->rNumericArgs(15);
-        Tank.OnCycLossFracToZone = state.dataIPShortCut->rNumericArgs(16);
+        Tank.OnCycLossCoeff = s_ipsc->rNumericArgs(15);
+        Tank.OnCycLossFracToZone = s_ipsc->rNumericArgs(16);
         Real64 rho = Tank.water->getDensity(state, Constant::InitConvTemp, routineName);
 
-        Tank.MassFlowRateMax = state.dataIPShortCut->rNumericArgs(17) * rho;
+        Tank.MassFlowRateMax = s_ipsc->rNumericArgs(17) * rho;
 
-        if ((state.dataIPShortCut->cAlphaArgs(14).empty()) && (state.dataIPShortCut->cAlphaArgs(15).empty())) {
-            if (state.dataIPShortCut->lAlphaFieldBlanks(12)) {
-            } else if ((Tank.flowRateSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(12))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(12), state.dataIPShortCut->cAlphaArgs(12));
+        if ((s_ipsc->cAlphaArgs(14).empty()) && (s_ipsc->cAlphaArgs(15).empty())) {
+            if (s_ipsc->lAlphaFieldBlanks(12)) {
+            } else if ((Tank.flowRateSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(12))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(12), s_ipsc->cAlphaArgs(12));
                 ErrorsFound = true;
             }
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(13)) {
-        } else if ((Tank.useInletTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(13))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(13), state.dataIPShortCut->cAlphaArgs(13));
+        if (s_ipsc->lAlphaFieldBlanks(13)) {
+        } else if ((Tank.useInletTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(13))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(13), s_ipsc->cAlphaArgs(13));
             ErrorsFound = true;
         }
 
         if (NumNums > 17) {
-            if ((state.dataIPShortCut->rNumericArgs(18) > 1) || (state.dataIPShortCut->rNumericArgs(18) < 0)) {
+            if ((s_ipsc->rNumericArgs(18) > 1) || (s_ipsc->rNumericArgs(18) < 0)) {
                 ShowSevereError(state,
                                 format("{} = {}:  Use Side Effectiveness is out of bounds (0 to 1)",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1)));
                 ErrorsFound = true;
             }
-            Tank.UseEffectiveness = state.dataIPShortCut->rNumericArgs(18);
+            Tank.UseEffectiveness = s_ipsc->rNumericArgs(18);
         } else {
             Tank.UseEffectiveness = 1.0; // Default for stand-alone mode
         }
 
         if (NumNums > 18) {
-            if ((state.dataIPShortCut->rNumericArgs(19) > 1) || (state.dataIPShortCut->rNumericArgs(19) <= 0)) {
+            if ((s_ipsc->rNumericArgs(19) > 1) || (s_ipsc->rNumericArgs(19) <= 0)) {
                 ShowSevereError(state,
                                 format("{} = {}:  Source Side Effectiveness is out of bounds (>0 to 1)",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1)));
                 ErrorsFound = true;
             }
-            Tank.SourceEffectiveness = state.dataIPShortCut->rNumericArgs(19);
+            Tank.SourceEffectiveness = s_ipsc->rNumericArgs(19);
         } else {
             Tank.SourceEffectiveness = 1.0;
         }
 
         // If no plant nodes are connected, simulate in stand-alone mode.
-        if (state.dataIPShortCut->cAlphaArgs(14).empty() && state.dataIPShortCut->cAlphaArgs(15).empty() &&
-            state.dataIPShortCut->cAlphaArgs(16).empty() && state.dataIPShortCut->cAlphaArgs(17).empty()) {
+        if (s_ipsc->cAlphaArgs(14).empty() && s_ipsc->cAlphaArgs(15).empty() &&
+            s_ipsc->cAlphaArgs(16).empty() && s_ipsc->cAlphaArgs(17).empty()) {
             Tank.StandAlone = true;
         }
 
-        if (!state.dataIPShortCut->lNumericFieldBlanks(20)) {
-            Tank.UseDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(20);
+        if (!s_ipsc->lNumericFieldBlanks(20)) {
+            Tank.UseDesignVolFlowRate = s_ipsc->rNumericArgs(20);
             if (Tank.UseDesignVolFlowRate == DataSizing::AutoSize) {
                 Tank.UseDesignVolFlowRateWasAutoSized = true;
             }
@@ -2604,8 +2547,8 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
         }
         Tank.UseSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if (!state.dataIPShortCut->lNumericFieldBlanks(21)) {
-            Tank.SourceDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(21);
+        if (!s_ipsc->lNumericFieldBlanks(21)) {
+            Tank.SourceDesignVolFlowRate = s_ipsc->rNumericArgs(21);
             if (Tank.SourceDesignVolFlowRate == DataSizing::AutoSize) {
                 Tank.SourceDesignVolFlowRateWasAutoSized = true;
             }
@@ -2614,102 +2557,102 @@ bool getWaterHeaterMixedInputs(EnergyPlusData &state)
         }
         Tank.SrcSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if (!state.dataIPShortCut->lNumericFieldBlanks(22)) {
-            Tank.SizingRecoveryTime = state.dataIPShortCut->rNumericArgs(22);
+        if (!s_ipsc->lNumericFieldBlanks(22)) {
+            Tank.SizingRecoveryTime = s_ipsc->rNumericArgs(22);
         } else {
             Tank.SizingRecoveryTime = 1.5;
         }
 
-        if ((!state.dataIPShortCut->cAlphaArgs(14).empty()) || (!state.dataIPShortCut->cAlphaArgs(15).empty())) {
+        if ((!s_ipsc->cAlphaArgs(14).empty()) || (!s_ipsc->cAlphaArgs(15).empty())) {
             Tank.UseInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                    state.dataIPShortCut->cAlphaArgs(14),
+                                                                    s_ipsc->cAlphaArgs(14),
                                                                     ErrorsFound,
                                                                     DataLoopNode::ConnectionObjectType::WaterHeaterMixed,
-                                                                    state.dataIPShortCut->cAlphaArgs(1),
+                                                                    s_ipsc->cAlphaArgs(1),
                                                                     DataLoopNode::NodeFluidType::Water,
                                                                     DataLoopNode::ConnectionType::Inlet,
                                                                     NodeInputManager::CompFluidStream::Primary,
                                                                     DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName1 = state.dataIPShortCut->cAlphaArgs(14);
+            Tank.InletNodeName1 = s_ipsc->cAlphaArgs(14);
             Tank.UseOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                     state.dataIPShortCut->cAlphaArgs(15),
+                                                                     s_ipsc->cAlphaArgs(15),
                                                                      ErrorsFound,
                                                                      DataLoopNode::ConnectionObjectType::WaterHeaterMixed,
-                                                                     state.dataIPShortCut->cAlphaArgs(1),
+                                                                     s_ipsc->cAlphaArgs(1),
                                                                      DataLoopNode::NodeFluidType::Water,
                                                                      DataLoopNode::ConnectionType::Outlet,
                                                                      NodeInputManager::CompFluidStream::Primary,
                                                                      DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName1 = state.dataIPShortCut->cAlphaArgs(15);
+            Tank.OutletNodeName1 = s_ipsc->cAlphaArgs(15);
 
-            if (state.dataIPShortCut->rNumericArgs(17) > 0) {
+            if (s_ipsc->rNumericArgs(17) > 0) {
                 ShowWarningError(state,
                                  format("{} = {}:  Use side nodes are specified; Peak Volumetric Use Flow Rate will not be used",
-                                        state.dataIPShortCut->cCurrentModuleObject,
-                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                        s_ipsc->cCurrentModuleObject,
+                                        s_ipsc->cAlphaArgs(1)));
             }
 
             if (Tank.flowRateSched != nullptr) {
                 ShowWarningError(state,
                                  format("{} = {}:  Use side nodes are specified; Use Flow Rate Fraction Schedule will not be used",
-                                        state.dataIPShortCut->cCurrentModuleObject,
-                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                        s_ipsc->cCurrentModuleObject,
+                                        s_ipsc->cAlphaArgs(1)));
             }
 
             if (Tank.useInletTempSched != nullptr) {
                 ShowWarningError(state,
                                  format("{} = {}:  Use side nodes are specified; Cold Water Supply Temperature Schedule will not be used",
-                                        state.dataIPShortCut->cCurrentModuleObject,
-                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                        s_ipsc->cCurrentModuleObject,
+                                        s_ipsc->cAlphaArgs(1)));
             }
         }
 
-        if ((!state.dataIPShortCut->cAlphaArgs(16).empty()) || (!state.dataIPShortCut->cAlphaArgs(17).empty())) {
+        if ((!s_ipsc->cAlphaArgs(16).empty()) || (!s_ipsc->cAlphaArgs(17).empty())) {
             Tank.SourceInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                       state.dataIPShortCut->cAlphaArgs(16),
+                                                                       s_ipsc->cAlphaArgs(16),
                                                                        ErrorsFound,
                                                                        DataLoopNode::ConnectionObjectType::WaterHeaterMixed,
-                                                                       state.dataIPShortCut->cAlphaArgs(1),
+                                                                       s_ipsc->cAlphaArgs(1),
                                                                        DataLoopNode::NodeFluidType::Water,
                                                                        DataLoopNode::ConnectionType::Inlet,
                                                                        NodeInputManager::CompFluidStream::Secondary,
                                                                        DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName2 = state.dataIPShortCut->cAlphaArgs(16);
+            Tank.InletNodeName2 = s_ipsc->cAlphaArgs(16);
             Tank.SourceOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                        state.dataIPShortCut->cAlphaArgs(17),
+                                                                        s_ipsc->cAlphaArgs(17),
                                                                         ErrorsFound,
                                                                         DataLoopNode::ConnectionObjectType::WaterHeaterMixed,
-                                                                        state.dataIPShortCut->cAlphaArgs(1),
+                                                                        s_ipsc->cAlphaArgs(1),
                                                                         DataLoopNode::NodeFluidType::Water,
                                                                         DataLoopNode::ConnectionType::Outlet,
                                                                         NodeInputManager::CompFluidStream::Secondary,
                                                                         DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName2 = state.dataIPShortCut->cAlphaArgs(17);
+            Tank.OutletNodeName2 = s_ipsc->cAlphaArgs(17);
         }
 
-        if (!state.dataIPShortCut->lAlphaFieldBlanks(18)) {
+        if (!s_ipsc->lAlphaFieldBlanks(18)) {
             Tank.SourceSideControlMode =
-                static_cast<SourceSideControl>(getEnumValue(SourceSideControlNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(18))));
+                static_cast<SourceSideControl>(getEnumValue(SourceSideControlNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(18))));
             if (Tank.SourceSideControlMode == SourceSideControl::Invalid) {
                 ShowSevereError(state,
                                 format("{} = {}:  Invalid Control Mode entered={}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(18)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(18)));
                 ErrorsFound = true;
             }
         } else {
             Tank.SourceSideControlMode = SourceSideControl::IndirectHeatPrimarySetpoint;
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(19)) {
-        } else if ((Tank.sourceSideAltSetpointSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(19))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(19), state.dataIPShortCut->cAlphaArgs(19));
+        if (s_ipsc->lAlphaFieldBlanks(19)) {
+        } else if ((Tank.sourceSideAltSetpointSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(19))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(19), s_ipsc->cAlphaArgs(19));
             ErrorsFound = true;
         }
 
         if (NumAlphas > 19) {
-            Tank.EndUseSubcategoryName = state.dataIPShortCut->cAlphaArgs(20);
+            Tank.EndUseSubcategoryName = s_ipsc->cAlphaArgs(20);
         }
 
     } // WaterThermalTankNum
@@ -2722,7 +2665,8 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
     bool ErrorsFound = false;
     static constexpr std::string_view routineName = "getWaterHeaterStratifiedInput";
 
-    state.dataIPShortCut->cCurrentModuleObject = cStratifiedWHModuleObj; //'WaterHeater:Stratified'
+    auto &s_ipsc = state.dataIPShortCut;
+    s_ipsc->cCurrentModuleObject = cStratifiedWHModuleObj; //'WaterHeater:Stratified'
 
     for (int WaterThermalTankNum = state.dataWaterThermalTanks->numWaterHeaterMixed + 1;
          WaterThermalTankNum <= state.dataWaterThermalTanks->numWaterHeaterMixed + state.dataWaterThermalTanks->numWaterHeaterStratified;
@@ -2731,31 +2675,31 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         int NumNums;
         int IOStat;
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 state.dataIPShortCut->cCurrentModuleObject,
+                                                                 s_ipsc->cCurrentModuleObject,
                                                                  WaterThermalTankNum - state.dataWaterThermalTanks->numWaterHeaterMixed,
-                                                                 state.dataIPShortCut->cAlphaArgs,
+                                                                 s_ipsc->cAlphaArgs,
                                                                  NumAlphas,
-                                                                 state.dataIPShortCut->rNumericArgs,
+                                                                 s_ipsc->rNumericArgs,
                                                                  NumNums,
                                                                  IOStat,
-                                                                 state.dataIPShortCut->lNumericFieldBlanks,
-                                                                 state.dataIPShortCut->lAlphaFieldBlanks,
-                                                                 state.dataIPShortCut->cAlphaFieldNames,
-                                                                 state.dataIPShortCut->cNumericFieldNames);
+                                                                 s_ipsc->lNumericFieldBlanks,
+                                                                 s_ipsc->lAlphaFieldBlanks,
+                                                                 s_ipsc->cAlphaFieldNames,
+                                                                 s_ipsc->cNumericFieldNames);
 
-        ErrorObjectHeader eoh{routineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)};
+        ErrorObjectHeader eoh{routineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)};
 
         GlobalNames::VerifyUniqueInterObjectName(state,
                                                  state.dataWaterThermalTanks->UniqueWaterThermalTankNames,
-                                                 state.dataIPShortCut->cAlphaArgs(1),
-                                                 state.dataIPShortCut->cCurrentModuleObject,
-                                                 state.dataIPShortCut->cAlphaFieldNames(1),
+                                                 s_ipsc->cAlphaArgs(1),
+                                                 s_ipsc->cCurrentModuleObject,
+                                                 s_ipsc->cAlphaFieldNames(1),
                                                  ErrorsFound);
 
         auto &Tank = state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum);
 
-        Tank.Name = state.dataIPShortCut->cAlphaArgs(1);
-        Tank.Type = state.dataIPShortCut->cCurrentModuleObject;
+        Tank.Name = s_ipsc->cAlphaArgs(1);
+        Tank.Type = s_ipsc->cCurrentModuleObject;
         Tank.WaterThermalTankType = DataPlant::PlantEquipmentType::WtrHeaterStratified;
 
         if ((Tank.water = Fluid::GetWater(state)) == nullptr) {
@@ -2767,33 +2711,33 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         Tank.sourceSideAvailSched = Sched::GetScheduleAlwaysOn(state);
         Tank.useSideAvailSched = Sched::GetScheduleAlwaysOn(state);
 
-        Tank.EndUseSubcategoryName = state.dataIPShortCut->cAlphaArgs(2);
+        Tank.EndUseSubcategoryName = s_ipsc->cAlphaArgs(2);
 
-        Tank.Volume = state.dataIPShortCut->rNumericArgs(1);
+        Tank.Volume = s_ipsc->rNumericArgs(1);
         if (Tank.Volume == DataSizing::AutoSize) {
             Tank.VolumeWasAutoSized = true;
         }
         Real64 rho = Tank.water->getDensity(state, Constant::InitConvTemp, routineName);
         Tank.Mass = Tank.Volume * rho;
-        Tank.Height = state.dataIPShortCut->rNumericArgs(2);
+        Tank.Height = s_ipsc->rNumericArgs(2);
         if (Tank.Height == DataSizing::AutoSize) {
             Tank.HeightWasAutoSized = true;
         }
 
-        Tank.Shape = static_cast<TankShape>(getEnumValue(TankShapeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(3))));
+        Tank.Shape = static_cast<TankShape>(getEnumValue(TankShapeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(3))));
         switch (Tank.Shape) {
         case TankShape::HorizCylinder:
         case TankShape::VertCylinder: {
             break;
         }
         case TankShape::Other: {
-            if (state.dataIPShortCut->rNumericArgs(3) > 0.0) {
-                Tank.Perimeter = state.dataIPShortCut->rNumericArgs(3);
+            if (s_ipsc->rNumericArgs(3) > 0.0) {
+                Tank.Perimeter = s_ipsc->rNumericArgs(3);
             } else {
                 ShowSevereError(state,
                                 format("{} = {}:  Tank Perimeter must be greater than zero for Tank Shape=OTHER",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1)));
                 ErrorsFound = true;
             }
 
@@ -2802,17 +2746,17 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         default: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Tank Shape entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(3)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(3)));
             Tank.Shape = TankShape::VertCylinder;
             ErrorsFound = true;
             break;
         }
         }
 
-        if (state.dataIPShortCut->rNumericArgs(4) > 0.0) {
-            Tank.TankTempLimit = state.dataIPShortCut->rNumericArgs(4);
+        if (s_ipsc->rNumericArgs(4) > 0.0) {
+            Tank.TankTempLimit = s_ipsc->rNumericArgs(4);
         } else {
             // Default to very large number
             Tank.TankTempLimit = 1.0e9;
@@ -2820,37 +2764,37 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
 
         // Validate Heater Priority Control
         Tank.StratifiedControlMode =
-            static_cast<PriorityControlMode>(getEnumValue(PriorityControlModeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(4))));
+            static_cast<PriorityControlMode>(getEnumValue(PriorityControlModeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(4))));
         if (Tank.StratifiedControlMode == PriorityControlMode::Invalid) {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Heater Priority Control entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(4)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(4)));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(5)) {
-            ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(5));
+        if (s_ipsc->lAlphaFieldBlanks(5)) {
+            ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(5));
             ErrorsFound = true;
-        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(5))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(5), state.dataIPShortCut->cAlphaArgs(5));
+        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(5))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(5), s_ipsc->cAlphaArgs(5));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(5) > 0.0) {
-            Tank.DeadBandDeltaTemp = state.dataIPShortCut->rNumericArgs(5);
+        if (s_ipsc->rNumericArgs(5) > 0.0) {
+            Tank.DeadBandDeltaTemp = s_ipsc->rNumericArgs(5);
         } else {
             // Default to very small number (however it can't be TINY or it will break the algorithm)
             Tank.DeadBandDeltaTemp = 0.0001;
         }
 
-        Tank.MaxCapacity = state.dataIPShortCut->rNumericArgs(6);
+        Tank.MaxCapacity = s_ipsc->rNumericArgs(6);
         if (Tank.MaxCapacity == DataSizing::AutoSize) {
             Tank.MaxCapacityWasAutoSized = true;
         }
 
-        Tank.HeaterHeight1 = state.dataIPShortCut->rNumericArgs(7);
+        Tank.HeaterHeight1 = s_ipsc->rNumericArgs(7);
 
         // adjust tank height used in these calculations for testing heater height
         Real64 tankHeightForTesting;
@@ -2864,148 +2808,148 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         if ((!Tank.HeightWasAutoSized) && (Tank.HeaterHeight1 > tankHeightForTesting)) {
             ShowSevereError(state,
                             format("{} = {}: Heater 1 is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(7), state.dataIPShortCut->rNumericArgs(7)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(7), s_ipsc->rNumericArgs(7)));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(6)) {
-            ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(6));
+        if (s_ipsc->lAlphaFieldBlanks(6)) {
+            ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(6));
             ErrorsFound = true;
-        } else if ((Tank.setptTemp2Sched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(6))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(6), state.dataIPShortCut->cAlphaArgs(6));
+        } else if ((Tank.setptTemp2Sched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(6))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(6), s_ipsc->cAlphaArgs(6));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(5) > 0.0) {
-            Tank.DeadBandDeltaTemp2 = state.dataIPShortCut->rNumericArgs(8);
+        if (s_ipsc->rNumericArgs(5) > 0.0) {
+            Tank.DeadBandDeltaTemp2 = s_ipsc->rNumericArgs(8);
         } else {
             // Default to very small number (however it can't be TINY or it will break the algorithm)
             Tank.DeadBandDeltaTemp2 = 0.0001;
         }
 
-        Tank.MaxCapacity2 = state.dataIPShortCut->rNumericArgs(9);
-        Tank.HeaterHeight2 = state.dataIPShortCut->rNumericArgs(10);
+        Tank.MaxCapacity2 = s_ipsc->rNumericArgs(9);
+        Tank.HeaterHeight2 = s_ipsc->rNumericArgs(10);
 
         // Test if Heater height is within range
         if ((!Tank.HeightWasAutoSized) && (Tank.HeaterHeight2 > tankHeightForTesting)) {
             ShowSevereError(state,
                             format("{} = {}: Heater 2 is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(10), state.dataIPShortCut->rNumericArgs(10)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(10), s_ipsc->rNumericArgs(10)));
             ErrorsFound = true;
         }
 
         // Validate Heater Fuel Type
         Tank.FuelType = static_cast<Constant::eFuel>(
             getEnumValue(Constant::eFuelNamesUC,
-                         state.dataIPShortCut->cAlphaArgs(
+                         s_ipsc->cAlphaArgs(
                              7))); // returns all kinds of fuels including district heat and cool + steam, returns unassigned if unsupported
         if (Tank.FuelType == Constant::eFuel::Invalid) {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Heater Fuel Type entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(7)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(7)));
             // Set to Electric to avoid errors when setting up output variables
             Tank.FuelType = Constant::eFuel::Electricity;
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(11) > 0.0) {
-            Tank.Efficiency = state.dataIPShortCut->rNumericArgs(11);
-            if (state.dataIPShortCut->rNumericArgs(11) > 1.0) {
+        if (s_ipsc->rNumericArgs(11) > 0.0) {
+            Tank.Efficiency = s_ipsc->rNumericArgs(11);
+            if (s_ipsc->rNumericArgs(11) > 1.0) {
                 ShowWarningError(state,
                                  fmt::format("{} = {}: {}={} should not typically be greater than 1.",
-                                             state.dataIPShortCut->cCurrentModuleObject,
-                                             state.dataIPShortCut->cAlphaArgs(1),
-                                             state.dataIPShortCut->cNumericFieldNames(11),
-                                             state.dataIPShortCut->rNumericArgs(11)));
+                                             s_ipsc->cCurrentModuleObject,
+                                             s_ipsc->cAlphaArgs(1),
+                                             s_ipsc->cNumericFieldNames(11),
+                                             s_ipsc->rNumericArgs(11)));
             }
         } else {
             ShowSevereError(state,
                             format("{} = {}:  Heater Thermal Efficiency must be greater than zero",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
             ErrorsFound = true;
         }
 
-        Tank.OffCycParaLoad = state.dataIPShortCut->rNumericArgs(12);
+        Tank.OffCycParaLoad = s_ipsc->rNumericArgs(12);
 
         // Validate Off-Cycle Parasitic Fuel Type
         Tank.OffCycParaFuelType = static_cast<Constant::eFuel>(
             getEnumValue(Constant::eFuelNamesUC,
-                         state.dataIPShortCut->cAlphaArgs(
+                         s_ipsc->cAlphaArgs(
                              8))); // returns all kinds of fuels including district heat and cool + steam, returns unassigned if unsupported
         if (Tank.OffCycParaFuelType == Constant::eFuel::Invalid) {
-            if (state.dataIPShortCut->cAlphaArgs(8).empty()) {
+            if (s_ipsc->cAlphaArgs(8).empty()) {
                 Tank.OffCycParaFuelType = Tank.FuelType;
             } else {
                 ShowSevereError(state,
                                 format("{} = {}:  Invalid Off-Cycle Parasitic Fuel Type entered={}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(8)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(8)));
                 // Set to Electric to avoid errors when setting up output variables
                 Tank.OffCycParaFuelType = Constant::eFuel::Electricity;
                 ErrorsFound = true;
             }
         }
 
-        Tank.OffCycParaFracToTank = state.dataIPShortCut->rNumericArgs(13);
-        Tank.OffCycParaHeight = state.dataIPShortCut->rNumericArgs(14);
+        Tank.OffCycParaFracToTank = s_ipsc->rNumericArgs(13);
+        Tank.OffCycParaHeight = s_ipsc->rNumericArgs(14);
 
-        Tank.OnCycParaLoad = state.dataIPShortCut->rNumericArgs(15);
+        Tank.OnCycParaLoad = s_ipsc->rNumericArgs(15);
 
         // Validate On-Cycle Parasitic Fuel Type
         Tank.OnCycParaFuelType = static_cast<Constant::eFuel>(
             getEnumValue(Constant::eFuelNamesUC,
-                         state.dataIPShortCut->cAlphaArgs(
+                         s_ipsc->cAlphaArgs(
                              9))); // returns all kinds of fuels including district heat and cool + steam, returns unassigned if unsupported/empty
         if (Tank.OnCycParaFuelType == Constant::eFuel::Invalid) {
-            if (state.dataIPShortCut->cAlphaArgs(9).empty()) {
+            if (s_ipsc->cAlphaArgs(9).empty()) {
                 Tank.OnCycParaFuelType = Tank.FuelType;
             } else {
                 ShowSevereError(state,
                                 format("{} = {}:  Invalid On-Cycle Parasitic Fuel Type entered={}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(9)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(9)));
                 // Set to Electric to avoid errors when setting up output variables
                 Tank.OnCycParaFuelType = Constant::eFuel::Electricity;
                 ErrorsFound = true;
             }
         }
 
-        Tank.OnCycParaFracToTank = state.dataIPShortCut->rNumericArgs(16);
-        Tank.OnCycParaHeight = state.dataIPShortCut->rNumericArgs(17);
+        Tank.OnCycParaFracToTank = s_ipsc->rNumericArgs(16);
+        Tank.OnCycParaHeight = s_ipsc->rNumericArgs(17);
 
         Tank.AmbientTempIndicator =
-            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(10))));
+            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(10))));
         switch (Tank.AmbientTempIndicator) {
 
         case WTTAmbientTemp::Schedule: {
-            if (state.dataIPShortCut->lAlphaFieldBlanks(11)) {
-                ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(11));
+            if (s_ipsc->lAlphaFieldBlanks(11)) {
+                ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(11));
                 ErrorsFound = true;
-            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(11))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(11), state.dataIPShortCut->cAlphaArgs(11));
+            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(11))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(11), s_ipsc->cAlphaArgs(11));
                 ErrorsFound = true;
             }
         } break;
 
         case WTTAmbientTemp::TempZone: {
-            Tank.AmbientTempZone = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(12), state.dataHeatBal->Zone);
+            Tank.AmbientTempZone = Util::FindItemInList(s_ipsc->cAlphaArgs(12), state.dataHeatBal->Zone);
             if (Tank.AmbientTempZone == 0) {
                 ShowSevereError(state,
                                 format("{} = {}:  Ambient Temperature Zone not found = {}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(12)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(12)));
                 ErrorsFound = true;
             }
 
@@ -3013,25 +2957,25 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         }
         case WTTAmbientTemp::OutsideAir: {
             Tank.AmbientTempOutsideAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                 state.dataIPShortCut->cAlphaArgs(13),
+                                                                                 s_ipsc->cAlphaArgs(13),
                                                                                  ErrorsFound,
                                                                                  DataLoopNode::ConnectionObjectType::WaterHeaterStratified,
-                                                                                 state.dataIPShortCut->cAlphaArgs(1),
+                                                                                 s_ipsc->cAlphaArgs(1),
                                                                                  DataLoopNode::NodeFluidType::Air,
                                                                                  DataLoopNode::ConnectionType::Inlet,
                                                                                  NodeInputManager::CompFluidStream::Primary,
                                                                                  DataLoopNode::ObjectIsNotParent);
-            if (!state.dataIPShortCut->cAlphaArgs(13).empty()) {
+            if (!s_ipsc->cAlphaArgs(13).empty()) {
                 if (!OutAirNodeManager::CheckOutAirNodeNumber(state, Tank.AmbientTempOutsideAirNode)) {
                     ShowSevereError(state,
                                     format("{} = {}: Outdoor Air Node not on OutdoorAir:NodeList or OutdoorAir:Node",
-                                           state.dataIPShortCut->cCurrentModuleObject,
-                                           state.dataIPShortCut->cAlphaArgs(1)));
-                    ShowContinueError(state, format("...Referenced Node Name={}", state.dataIPShortCut->cAlphaArgs(13)));
+                                           s_ipsc->cCurrentModuleObject,
+                                           s_ipsc->cAlphaArgs(1)));
+                    ShowContinueError(state, format("...Referenced Node Name={}", s_ipsc->cAlphaArgs(13)));
                     ErrorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                ShowSevereError(state, format("{} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state, "An Ambient Outdoor Air Node name must be used when the Ambient Temperature Indicator is Outdoors.");
                 ErrorsFound = true;
             }
@@ -3041,47 +2985,47 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         default: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Ambient Temperature Indicator entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(10)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(10)));
             ShowContinueError(state, " Valid entries are Schedule, Zone, and Outdoors.");
             ErrorsFound = true;
             break;
         }
         }
 
-        Tank.SkinLossCoeff = state.dataIPShortCut->rNumericArgs(18);
-        Tank.SkinLossFracToZone = state.dataIPShortCut->rNumericArgs(19);
-        Tank.OffCycFlueLossCoeff = state.dataIPShortCut->rNumericArgs(20);
-        Tank.OffCycFlueLossFracToZone = state.dataIPShortCut->rNumericArgs(21);
+        Tank.SkinLossCoeff = s_ipsc->rNumericArgs(18);
+        Tank.SkinLossFracToZone = s_ipsc->rNumericArgs(19);
+        Tank.OffCycFlueLossCoeff = s_ipsc->rNumericArgs(20);
+        Tank.OffCycFlueLossFracToZone = s_ipsc->rNumericArgs(21);
 
         // this is temporary until we know fluid type
         rho = Tank.water->getDensity(state, Constant::InitConvTemp, routineName);
 
-        Tank.MassFlowRateMax = state.dataIPShortCut->rNumericArgs(22) * rho;
+        Tank.MassFlowRateMax = s_ipsc->rNumericArgs(22) * rho;
 
-        if ((state.dataIPShortCut->cAlphaArgs(16).empty()) && (state.dataIPShortCut->cAlphaArgs(17).empty())) {
-            if (state.dataIPShortCut->lAlphaFieldBlanks(14)) {
-            } else if ((Tank.flowRateSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(14))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(14), state.dataIPShortCut->cAlphaArgs(14));
+        if ((s_ipsc->cAlphaArgs(16).empty()) && (s_ipsc->cAlphaArgs(17).empty())) {
+            if (s_ipsc->lAlphaFieldBlanks(14)) {
+            } else if ((Tank.flowRateSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(14))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(14), s_ipsc->cAlphaArgs(14));
                 ErrorsFound = true;
             }
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(15)) {
-        } else if ((Tank.useInletTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(15))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(15), state.dataIPShortCut->cAlphaArgs(15));
+        if (s_ipsc->lAlphaFieldBlanks(15)) {
+        } else if ((Tank.useInletTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(15))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(15), s_ipsc->cAlphaArgs(15));
             ErrorsFound = true;
         }
 
         if (NumNums > 22) {
-            Tank.UseEffectiveness = state.dataIPShortCut->rNumericArgs(23);
+            Tank.UseEffectiveness = s_ipsc->rNumericArgs(23);
         } else {
             Tank.UseEffectiveness = 1.0; // Default for stand-alone mode
         }
 
         if (NumNums > 23) {
-            Tank.UseInletHeight = state.dataIPShortCut->rNumericArgs(24);
+            Tank.UseInletHeight = s_ipsc->rNumericArgs(24);
         } else {
             // Defaults to bottom of tank
             Tank.UseInletHeight = 0.0;
@@ -3089,15 +3033,15 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         if ((!Tank.HeightWasAutoSized) && (Tank.UseInletHeight > Tank.Height)) {
             ShowSevereError(state,
                             format("{} = {}: Use inlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(24), state.dataIPShortCut->rNumericArgs(24)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(24), s_ipsc->rNumericArgs(24)));
             ErrorsFound = true;
         }
 
-        if ((NumNums > 24) && (state.dataIPShortCut->rNumericArgs(25) != Constant::AutoCalculate)) {
-            Tank.UseOutletHeight = state.dataIPShortCut->rNumericArgs(25);
+        if ((NumNums > 24) && (s_ipsc->rNumericArgs(25) != Constant::AutoCalculate)) {
+            Tank.UseOutletHeight = s_ipsc->rNumericArgs(25);
         } else {
             // Defaults to top of tank
             Tank.UseOutletHeight = Tank.Height;
@@ -3108,28 +3052,28 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         if ((!Tank.HeightWasAutoSized) && (Tank.UseOutletHeight > Tank.Height)) {
             ShowSevereError(state,
                             format("{} = {}: Use outlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(25), state.dataIPShortCut->rNumericArgs(25)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(25), s_ipsc->rNumericArgs(25)));
             ErrorsFound = true;
         }
 
         if (NumNums > 25) {
-            if ((state.dataIPShortCut->rNumericArgs(26) > 1) || (state.dataIPShortCut->rNumericArgs(26) <= 0)) {
+            if ((s_ipsc->rNumericArgs(26) > 1) || (s_ipsc->rNumericArgs(26) <= 0)) {
                 ShowSevereError(state,
                                 format("{} = {}:  Source Side Effectiveness is out of bounds (>0 to 1)",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1)));
                 ErrorsFound = true;
             }
-            Tank.SourceEffectiveness = state.dataIPShortCut->rNumericArgs(26);
+            Tank.SourceEffectiveness = s_ipsc->rNumericArgs(26);
         } else {
             Tank.SourceEffectiveness = 1.0;
         }
 
-        if ((NumNums > 26) && (state.dataIPShortCut->rNumericArgs(27) != Constant::AutoCalculate)) {
-            Tank.SourceInletHeight = state.dataIPShortCut->rNumericArgs(27);
+        if ((NumNums > 26) && (s_ipsc->rNumericArgs(27) != Constant::AutoCalculate)) {
+            Tank.SourceInletHeight = s_ipsc->rNumericArgs(27);
         } else {
             // Defaults to top of tank
             Tank.SourceInletHeight = Tank.Height;
@@ -3140,15 +3084,15 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         if ((!Tank.HeightWasAutoSized) && (Tank.SourceInletHeight > Tank.Height)) {
             ShowSevereError(state,
                             format("{} = {}: Source inlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(27), state.dataIPShortCut->rNumericArgs(27)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(27), s_ipsc->rNumericArgs(27)));
             ErrorsFound = true;
         }
 
-        if ((NumNums > 27) && (state.dataIPShortCut->rNumericArgs(28) != Constant::AutoCalculate)) {
-            Tank.SourceOutletHeight = state.dataIPShortCut->rNumericArgs(28);
+        if ((NumNums > 27) && (s_ipsc->rNumericArgs(28) != Constant::AutoCalculate)) {
+            Tank.SourceOutletHeight = s_ipsc->rNumericArgs(28);
         } else {
             // Defaults to bottom of tank
             Tank.SourceOutletHeight = 0.0;
@@ -3156,20 +3100,20 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         if ((!Tank.HeightWasAutoSized) && (Tank.SourceOutletHeight > Tank.Height)) {
             ShowSevereError(state,
                             format("{} = {}: Source outlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(28), state.dataIPShortCut->rNumericArgs(28)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(28), s_ipsc->rNumericArgs(28)));
             ErrorsFound = true;
         }
 
         // If no plant nodes are connected, simulate in stand-alone mode.
-        if (state.dataIPShortCut->cAlphaArgs(16).empty() && state.dataIPShortCut->cAlphaArgs(17).empty() &&
-            state.dataIPShortCut->cAlphaArgs(18).empty() && state.dataIPShortCut->cAlphaArgs(19).empty())
+        if (s_ipsc->cAlphaArgs(16).empty() && s_ipsc->cAlphaArgs(17).empty() &&
+            s_ipsc->cAlphaArgs(18).empty() && s_ipsc->cAlphaArgs(19).empty())
             Tank.StandAlone = true;
 
-        if (!state.dataIPShortCut->lNumericFieldBlanks(29)) {
-            Tank.UseDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(29);
+        if (!s_ipsc->lNumericFieldBlanks(29)) {
+            Tank.UseDesignVolFlowRate = s_ipsc->rNumericArgs(29);
             if (Tank.UseDesignVolFlowRate == DataSizing::AutoSize) {
                 Tank.UseDesignVolFlowRateWasAutoSized = true;
             }
@@ -3179,8 +3123,8 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
 
         Tank.UseSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if (!state.dataIPShortCut->lNumericFieldBlanks(30)) {
-            Tank.SourceDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(30);
+        if (!s_ipsc->lNumericFieldBlanks(30)) {
+            Tank.SourceDesignVolFlowRate = s_ipsc->rNumericArgs(30);
             if (Tank.SourceDesignVolFlowRate == DataSizing::AutoSize) {
                 Tank.SourceDesignVolFlowRateWasAutoSized = true;
             }
@@ -3189,87 +3133,87 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
         }
 
         if (NumNums > 30) {
-            Tank.SizingRecoveryTime = state.dataIPShortCut->rNumericArgs(31);
+            Tank.SizingRecoveryTime = s_ipsc->rNumericArgs(31);
         } else {
             Tank.SizingRecoveryTime = 1.5;
         }
 
         Tank.SrcSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if ((!state.dataIPShortCut->cAlphaArgs(16).empty()) || (!state.dataIPShortCut->cAlphaArgs(17).empty())) {
+        if ((!s_ipsc->cAlphaArgs(16).empty()) || (!s_ipsc->cAlphaArgs(17).empty())) {
             Tank.UseInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                    state.dataIPShortCut->cAlphaArgs(16),
+                                                                    s_ipsc->cAlphaArgs(16),
                                                                     ErrorsFound,
                                                                     DataLoopNode::ConnectionObjectType::WaterHeaterStratified,
-                                                                    state.dataIPShortCut->cAlphaArgs(1),
+                                                                    s_ipsc->cAlphaArgs(1),
                                                                     DataLoopNode::NodeFluidType::Water,
                                                                     DataLoopNode::ConnectionType::Inlet,
                                                                     NodeInputManager::CompFluidStream::Primary,
                                                                     DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName1 = state.dataIPShortCut->cAlphaArgs(16);
+            Tank.InletNodeName1 = s_ipsc->cAlphaArgs(16);
             Tank.UseOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                     state.dataIPShortCut->cAlphaArgs(17),
+                                                                     s_ipsc->cAlphaArgs(17),
                                                                      ErrorsFound,
                                                                      DataLoopNode::ConnectionObjectType::WaterHeaterStratified,
-                                                                     state.dataIPShortCut->cAlphaArgs(1),
+                                                                     s_ipsc->cAlphaArgs(1),
                                                                      DataLoopNode::NodeFluidType::Water,
                                                                      DataLoopNode::ConnectionType::Outlet,
                                                                      NodeInputManager::CompFluidStream::Primary,
                                                                      DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName1 = state.dataIPShortCut->cAlphaArgs(17);
+            Tank.OutletNodeName1 = s_ipsc->cAlphaArgs(17);
 
-            if (state.dataIPShortCut->rNumericArgs(22) > 0) {
+            if (s_ipsc->rNumericArgs(22) > 0) {
                 ShowWarningError(state,
                                  format("{} = {}:  Use side nodes are specified; Peak Volumetric Use Flow Rate will not be used",
-                                        state.dataIPShortCut->cCurrentModuleObject,
-                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                        s_ipsc->cCurrentModuleObject,
+                                        s_ipsc->cAlphaArgs(1)));
             }
 
             if (Tank.flowRateSched != nullptr) {
                 ShowWarningError(state,
                                  format("{} = {}:  Use side nodes are specified; Use Flow Rate Fraction Schedule will not be used",
-                                        state.dataIPShortCut->cCurrentModuleObject,
-                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                        s_ipsc->cCurrentModuleObject,
+                                        s_ipsc->cAlphaArgs(1)));
             }
 
             if (Tank.useInletTempSched != nullptr) {
                 ShowWarningError(state,
                                  format("{} = {}:  Use side nodes are specified; Cold Water Supply Temperature Schedule will not be used",
-                                        state.dataIPShortCut->cCurrentModuleObject,
-                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                        s_ipsc->cCurrentModuleObject,
+                                        s_ipsc->cAlphaArgs(1)));
             }
         }
 
-        if ((!state.dataIPShortCut->cAlphaArgs(18).empty()) || (!state.dataIPShortCut->cAlphaArgs(19).empty())) {
+        if ((!s_ipsc->cAlphaArgs(18).empty()) || (!s_ipsc->cAlphaArgs(19).empty())) {
             Tank.SourceInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                       state.dataIPShortCut->cAlphaArgs(18),
+                                                                       s_ipsc->cAlphaArgs(18),
                                                                        ErrorsFound,
                                                                        DataLoopNode::ConnectionObjectType::WaterHeaterStratified,
-                                                                       state.dataIPShortCut->cAlphaArgs(1),
+                                                                       s_ipsc->cAlphaArgs(1),
                                                                        DataLoopNode::NodeFluidType::Water,
                                                                        DataLoopNode::ConnectionType::Inlet,
                                                                        NodeInputManager::CompFluidStream::Secondary,
                                                                        DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName2 = state.dataIPShortCut->cAlphaArgs(18);
+            Tank.InletNodeName2 = s_ipsc->cAlphaArgs(18);
             Tank.SourceOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                        state.dataIPShortCut->cAlphaArgs(19),
+                                                                        s_ipsc->cAlphaArgs(19),
                                                                         ErrorsFound,
                                                                         DataLoopNode::ConnectionObjectType::WaterHeaterStratified,
-                                                                        state.dataIPShortCut->cAlphaArgs(1),
+                                                                        s_ipsc->cAlphaArgs(1),
                                                                         DataLoopNode::NodeFluidType::Water,
                                                                         DataLoopNode::ConnectionType::Outlet,
                                                                         NodeInputManager::CompFluidStream::Secondary,
                                                                         DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName2 = state.dataIPShortCut->cAlphaArgs(19);
+            Tank.OutletNodeName2 = s_ipsc->cAlphaArgs(19);
         }
 
         // Validate inlet mode
         Tank.InletMode =
-            static_cast<InletPositionMode>(getEnumValue(InletPositionModeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(20))));
+            static_cast<InletPositionMode>(getEnumValue(InletPositionModeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(20))));
 
-        Tank.Nodes = state.dataIPShortCut->rNumericArgs(32);
+        Tank.Nodes = s_ipsc->rNumericArgs(32);
         int specifiedNodes = 0;
-        Tank.AdditionalCond = state.dataIPShortCut->rNumericArgs(33);
+        Tank.AdditionalCond = s_ipsc->rNumericArgs(33);
 
         Tank.AdditionalLossCoeff.allocate(Tank.Nodes);
         Tank.AdditionalLossCoeff = 0.0;
@@ -3278,8 +3222,8 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
             if (NumNums >= index) {
                 if (NodeNum <= Tank.Nodes) {
                     ++specifiedNodes;
-                    Tank.AdditionalLossCoeff(NodeNum) = state.dataIPShortCut->rNumericArgs(index);
-                } else if (!state.dataIPShortCut->lNumericFieldBlanks(index) && (state.dataIPShortCut->rNumericArgs(index) != 0)) {
+                    Tank.AdditionalLossCoeff(NodeNum) = s_ipsc->rNumericArgs(index);
+                } else if (!s_ipsc->lNumericFieldBlanks(index) && (s_ipsc->rNumericArgs(index) != 0)) {
                     // If either blank, or zero (default), then do not warn
                     ++specifiedNodes;
                 }
@@ -3292,30 +3236,30 @@ bool getWaterHeaterStratifiedInput(EnergyPlusData &state)
             ShowWarningError(
                 state,
                 format("{} = {}:  More Additional Loss Coefficients were entered than the number of nodes; extra coefficients will not be used",
-                       state.dataIPShortCut->cCurrentModuleObject,
-                       state.dataIPShortCut->cAlphaArgs(1)));
+                       s_ipsc->cCurrentModuleObject,
+                       s_ipsc->cAlphaArgs(1)));
         }
 
         Tank.SetupStratifiedNodes(state);
 
-        if (!state.dataIPShortCut->lAlphaFieldBlanks(21)) {
+        if (!s_ipsc->lAlphaFieldBlanks(21)) {
             Tank.SourceSideControlMode =
-                static_cast<SourceSideControl>(getEnumValue(SourceSideControlNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(21))));
+                static_cast<SourceSideControl>(getEnumValue(SourceSideControlNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(21))));
             if (Tank.SourceSideControlMode == SourceSideControl::Invalid) {
                 ShowSevereError(state,
                                 format("{} = {}:  Invalid Control Mode entered={}",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1),
-                                       state.dataIPShortCut->cAlphaArgs(21)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1),
+                                       s_ipsc->cAlphaArgs(21)));
                 ErrorsFound = true;
             }
         } else {
             Tank.SourceSideControlMode = SourceSideControl::IndirectHeatPrimarySetpoint;
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(22)) {
-        } else if ((Tank.sourceSideAltSetpointSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(22))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(22), state.dataIPShortCut->cAlphaArgs(22));
+        if (s_ipsc->lAlphaFieldBlanks(22)) {
+        } else if ((Tank.sourceSideAltSetpointSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(22))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(22), s_ipsc->cAlphaArgs(22));
             ErrorsFound = true;
         }
     }
@@ -3328,7 +3272,9 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
     static constexpr std::string_view routineName = "getWaterTankMixedInput";
     bool ErrorsFound = false;
 
-    state.dataIPShortCut->cCurrentModuleObject = cMixedCWTankModuleObj; // 'ThermalStorage:ChilledWater:Mixed'
+    auto &s_ipsc = state.dataIPShortCut;
+    
+    s_ipsc->cCurrentModuleObject = cMixedCWTankModuleObj; // 'ThermalStorage:ChilledWater:Mixed'
     for (int WaterThermalTankNum = state.dataWaterThermalTanks->numWaterHeaterMixed + state.dataWaterThermalTanks->numWaterHeaterStratified + 1;
          WaterThermalTankNum <= state.dataWaterThermalTanks->numWaterHeaterMixed + state.dataWaterThermalTanks->numWaterHeaterStratified +
                                     state.dataWaterThermalTanks->numChilledWaterMixed;
@@ -3338,31 +3284,31 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
         int IOStat;
         state.dataInputProcessing->inputProcessor->getObjectItem(
             state,
-            state.dataIPShortCut->cCurrentModuleObject,
+            s_ipsc->cCurrentModuleObject,
             WaterThermalTankNum - (state.dataWaterThermalTanks->numWaterHeaterMixed + state.dataWaterThermalTanks->numWaterHeaterStratified),
-            state.dataIPShortCut->cAlphaArgs,
+            s_ipsc->cAlphaArgs,
             NumAlphas,
-            state.dataIPShortCut->rNumericArgs,
+            s_ipsc->rNumericArgs,
             NumNums,
             IOStat,
-            state.dataIPShortCut->lNumericFieldBlanks,
-            state.dataIPShortCut->lAlphaFieldBlanks,
-            state.dataIPShortCut->cAlphaFieldNames,
-            state.dataIPShortCut->cNumericFieldNames);
+            s_ipsc->lNumericFieldBlanks,
+            s_ipsc->lAlphaFieldBlanks,
+            s_ipsc->cAlphaFieldNames,
+            s_ipsc->cNumericFieldNames);
 
-        ErrorObjectHeader eoh{routineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)};
+        ErrorObjectHeader eoh{routineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)};
 
         GlobalNames::VerifyUniqueInterObjectName(state,
                                                  state.dataWaterThermalTanks->UniqueWaterThermalTankNames,
-                                                 state.dataIPShortCut->cAlphaArgs(1),
-                                                 state.dataIPShortCut->cCurrentModuleObject,
-                                                 state.dataIPShortCut->cAlphaFieldNames(1),
+                                                 s_ipsc->cAlphaArgs(1),
+                                                 s_ipsc->cCurrentModuleObject,
+                                                 s_ipsc->cAlphaFieldNames(1),
                                                  ErrorsFound);
 
         auto &Tank = state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum);
 
-        Tank.Name = state.dataIPShortCut->cAlphaArgs(1);
-        Tank.Type = state.dataIPShortCut->cCurrentModuleObject;
+        Tank.Name = s_ipsc->cAlphaArgs(1);
+        Tank.Type = s_ipsc->cCurrentModuleObject;
         Tank.WaterThermalTankType = DataPlant::PlantEquipmentType::ChilledWaterTankMixed;
 
         if ((Tank.water = Fluid::GetWater(state)) == nullptr) {
@@ -3373,38 +3319,38 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
         Tank.IsChilledWaterTank = true;
         Tank.EndUseSubcategoryName = "Chilled Water Storage";
 
-        Tank.Volume = state.dataIPShortCut->rNumericArgs(1);
+        Tank.Volume = s_ipsc->rNumericArgs(1);
         if (Tank.Volume == DataSizing::AutoSize) {
             Tank.VolumeWasAutoSized = true;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(1) == 0.0) {
+        if (s_ipsc->rNumericArgs(1) == 0.0) {
             // Set volume to a really small number to continue simulation
             Tank.Volume = 0.000001; // = 1 cm3
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(2)) {
-            ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(2));
-        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(2))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(2), state.dataIPShortCut->cAlphaArgs(2));
+        if (s_ipsc->lAlphaFieldBlanks(2)) {
+            ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(2));
+        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(2))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(2), s_ipsc->cAlphaArgs(2));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(2) > 0.0001) {
-            Tank.DeadBandDeltaTemp = state.dataIPShortCut->rNumericArgs(2);
+        if (s_ipsc->rNumericArgs(2) > 0.0001) {
+            Tank.DeadBandDeltaTemp = s_ipsc->rNumericArgs(2);
         } else {
             // Default to very small number (however it can't be TINY or it will break the algorithm)
             Tank.DeadBandDeltaTemp = 0.5;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(3) > 0.0) {
-            Tank.TankTempLimit = state.dataIPShortCut->rNumericArgs(3);
+        if (s_ipsc->rNumericArgs(3) > 0.0) {
+            Tank.TankTempLimit = s_ipsc->rNumericArgs(3);
         } else {
             // default to just above freezing
             Tank.TankTempLimit = 1.0;
         }
 
-        Tank.MaxCapacity = state.dataIPShortCut->rNumericArgs(4);
+        Tank.MaxCapacity = s_ipsc->rNumericArgs(4);
         if (Tank.MaxCapacity == DataSizing::AutoSize) {
             Tank.MaxCapacityWasAutoSized = true;
         }
@@ -3425,24 +3371,24 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
         Tank.OnCycParaFracToTank = 0.0;
 
         Tank.AmbientTempIndicator =
-            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(3))));
+            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(3))));
         switch (Tank.AmbientTempIndicator) {
 
         case WTTAmbientTemp::Schedule: {
-            if (state.dataIPShortCut->lAlphaFieldBlanks(4)) {
-                ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(4));
-            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(4))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(4), state.dataIPShortCut->cAlphaArgs(4));
+            if (s_ipsc->lAlphaFieldBlanks(4)) {
+                ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(4));
+            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(4))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(4), s_ipsc->cAlphaArgs(4));
                 ErrorsFound = true;
             }
         } break;
 
         case WTTAmbientTemp::TempZone: {
-            Tank.AmbientTempZone = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(5), state.dataHeatBal->Zone);
+            Tank.AmbientTempZone = Util::FindItemInList(s_ipsc->cAlphaArgs(5), state.dataHeatBal->Zone);
             if (Tank.AmbientTempZone == 0) {
-                ShowSevereError(state, format("Invalid, {} = {}", state.dataIPShortCut->cAlphaFieldNames(5), state.dataIPShortCut->cAlphaArgs(5)));
+                ShowSevereError(state, format("Invalid, {} = {}", s_ipsc->cAlphaFieldNames(5), s_ipsc->cAlphaArgs(5)));
                 ShowContinueError(state,
-                                  format("Entered in {} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                                  format("Entered in {} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state, "Zone was not found.");
                 ErrorsFound = true;
             }
@@ -3451,25 +3397,25 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
         }
         case WTTAmbientTemp::OutsideAir: {
             Tank.AmbientTempOutsideAirNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                                 state.dataIPShortCut->cAlphaArgs(6),
+                                                                                 s_ipsc->cAlphaArgs(6),
                                                                                  ErrorsFound,
                                                                                  DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterMixed,
-                                                                                 state.dataIPShortCut->cAlphaArgs(1),
+                                                                                 s_ipsc->cAlphaArgs(1),
                                                                                  DataLoopNode::NodeFluidType::Air,
                                                                                  DataLoopNode::ConnectionType::OutsideAirReference,
                                                                                  NodeInputManager::CompFluidStream::Primary,
                                                                                  DataLoopNode::ObjectIsNotParent);
-            if (!state.dataIPShortCut->lAlphaFieldBlanks(6)) {
+            if (!s_ipsc->lAlphaFieldBlanks(6)) {
                 if (!OutAirNodeManager::CheckOutAirNodeNumber(state, Tank.AmbientTempOutsideAirNode)) {
                     ShowSevereError(state,
-                                    format("Invalid, {} = {}", state.dataIPShortCut->cAlphaFieldNames(6), state.dataIPShortCut->cAlphaArgs(6)));
+                                    format("Invalid, {} = {}", s_ipsc->cAlphaFieldNames(6), s_ipsc->cAlphaArgs(6)));
                     ShowContinueError(state,
-                                      format("Entered in {} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                                      format("Entered in {} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                     ShowContinueError(state, "Outdoor Air Node not on OutdoorAir:NodeList or OutdoorAir:Node");
                     ErrorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                ShowSevereError(state, format("{} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state, "An Ambient Outdoor Air Node name must be used when the Ambient Temperature Indicator is Outdoors.");
                 ErrorsFound = true;
             }
@@ -3479,19 +3425,19 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
         default: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Ambient Temperature Indicator entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(3)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(3)));
             ShowContinueError(state, " Valid entries are Schedule, Zone, and Outdoors.");
             ErrorsFound = true;
             break;
         }
         }
 
-        Tank.OffCycLossCoeff = state.dataIPShortCut->rNumericArgs(5);
+        Tank.OffCycLossCoeff = s_ipsc->rNumericArgs(5);
         Tank.OffCycLossFracToZone = 1.0;
 
-        Tank.OnCycLossCoeff = state.dataIPShortCut->rNumericArgs(5);
+        Tank.OnCycLossCoeff = s_ipsc->rNumericArgs(5);
         Tank.OnCycLossFracToZone = 1.0;
 
         Tank.MassFlowRateMax = 0.0;
@@ -3502,28 +3448,28 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
         Tank.sourceSideAvailSched = Sched::GetScheduleAlwaysOn(state);
         Tank.useSideAvailSched = Sched::GetScheduleAlwaysOn(state);
 
-        if ((state.dataIPShortCut->rNumericArgs(6) > 1) || (state.dataIPShortCut->rNumericArgs(6) < 0)) {
+        if ((s_ipsc->rNumericArgs(6) > 1) || (s_ipsc->rNumericArgs(6) < 0)) {
             ShowSevereError(state,
                             format("{} = {}:  Use Side Effectiveness is out of bounds (0 to 1)",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
             ErrorsFound = true;
         }
-        Tank.UseEffectiveness = state.dataIPShortCut->rNumericArgs(6);
+        Tank.UseEffectiveness = s_ipsc->rNumericArgs(6);
 
-        if ((state.dataIPShortCut->rNumericArgs(8) > 1) || (state.dataIPShortCut->rNumericArgs(8) <= 0)) {
+        if ((s_ipsc->rNumericArgs(8) > 1) || (s_ipsc->rNumericArgs(8) <= 0)) {
             ShowSevereError(state,
                             format("{} = {}:  Source Side Effectiveness is out of bounds (>0 to 1)",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
             ErrorsFound = true;
         }
-        Tank.SourceEffectiveness = state.dataIPShortCut->rNumericArgs(8);
+        Tank.SourceEffectiveness = s_ipsc->rNumericArgs(8);
 
-        if (state.dataIPShortCut->lNumericFieldBlanks(7)) {
+        if (s_ipsc->lNumericFieldBlanks(7)) {
             Tank.UseDesignVolFlowRate = 0.0;
         } else {
-            Tank.UseDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(7);
+            Tank.UseDesignVolFlowRate = s_ipsc->rNumericArgs(7);
             if (Tank.UseDesignVolFlowRate) {
                 Tank.UseDesignVolFlowRateWasAutoSized = true;
             }
@@ -3531,81 +3477,81 @@ bool getWaterTankMixedInput(EnergyPlusData &state)
 
         Tank.UseSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(9)) {
+        if (s_ipsc->lAlphaFieldBlanks(9)) {
             Tank.useSideAvailSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((Tank.useSideAvailSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(9))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(9), state.dataIPShortCut->cAlphaArgs(9));
+        } else if ((Tank.useSideAvailSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(9))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(9), s_ipsc->cAlphaArgs(9));
             ErrorsFound = true;
         }
 
         Tank.SrcSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if (state.dataIPShortCut->lNumericFieldBlanks(9)) {
+        if (s_ipsc->lNumericFieldBlanks(9)) {
             Tank.SourceDesignVolFlowRate = 0.0;
         } else {
-            Tank.SourceDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(9);
+            Tank.SourceDesignVolFlowRate = s_ipsc->rNumericArgs(9);
             if (Tank.SourceDesignVolFlowRate == DataSizing::AutoSize) {
                 Tank.SourceDesignVolFlowRateWasAutoSized = true;
             }
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(12)) {
+        if (s_ipsc->lAlphaFieldBlanks(12)) {
             Tank.sourceSideAvailSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((Tank.sourceSideAvailSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(12))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(12), state.dataIPShortCut->cAlphaArgs(12));
+        } else if ((Tank.sourceSideAvailSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(12))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(12), s_ipsc->cAlphaArgs(12));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->lNumericFieldBlanks(10)) {
+        if (s_ipsc->lNumericFieldBlanks(10)) {
             Tank.SizingRecoveryTime = 4.0;
         } else {
-            Tank.SizingRecoveryTime = state.dataIPShortCut->rNumericArgs(10);
+            Tank.SizingRecoveryTime = s_ipsc->rNumericArgs(10);
         }
 
-        if ((!state.dataIPShortCut->lAlphaFieldBlanks(7)) || (!state.dataIPShortCut->lAlphaFieldBlanks(8))) {
+        if ((!s_ipsc->lAlphaFieldBlanks(7)) || (!s_ipsc->lAlphaFieldBlanks(8))) {
             Tank.UseInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                    state.dataIPShortCut->cAlphaArgs(7),
+                                                                    s_ipsc->cAlphaArgs(7),
                                                                     ErrorsFound,
                                                                     DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterMixed,
-                                                                    state.dataIPShortCut->cAlphaArgs(1),
+                                                                    s_ipsc->cAlphaArgs(1),
                                                                     DataLoopNode::NodeFluidType::Water,
                                                                     DataLoopNode::ConnectionType::Inlet,
                                                                     NodeInputManager::CompFluidStream::Primary,
                                                                     DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName1 = state.dataIPShortCut->cAlphaArgs(7);
+            Tank.InletNodeName1 = s_ipsc->cAlphaArgs(7);
             Tank.UseOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                     state.dataIPShortCut->cAlphaArgs(8),
+                                                                     s_ipsc->cAlphaArgs(8),
                                                                      ErrorsFound,
                                                                      DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterMixed,
-                                                                     state.dataIPShortCut->cAlphaArgs(1),
+                                                                     s_ipsc->cAlphaArgs(1),
                                                                      DataLoopNode::NodeFluidType::Water,
                                                                      DataLoopNode::ConnectionType::Outlet,
                                                                      NodeInputManager::CompFluidStream::Primary,
                                                                      DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName1 = state.dataIPShortCut->cAlphaArgs(8);
+            Tank.OutletNodeName1 = s_ipsc->cAlphaArgs(8);
         }
 
-        if ((!state.dataIPShortCut->lAlphaFieldBlanks(10)) || (!state.dataIPShortCut->lAlphaFieldBlanks(11))) {
+        if ((!s_ipsc->lAlphaFieldBlanks(10)) || (!s_ipsc->lAlphaFieldBlanks(11))) {
             Tank.SourceInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                       state.dataIPShortCut->cAlphaArgs(10),
+                                                                       s_ipsc->cAlphaArgs(10),
                                                                        ErrorsFound,
                                                                        DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterMixed,
-                                                                       state.dataIPShortCut->cAlphaArgs(1),
+                                                                       s_ipsc->cAlphaArgs(1),
                                                                        DataLoopNode::NodeFluidType::Water,
                                                                        DataLoopNode::ConnectionType::Inlet,
                                                                        NodeInputManager::CompFluidStream::Secondary,
                                                                        DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName2 = state.dataIPShortCut->cAlphaArgs(10);
+            Tank.InletNodeName2 = s_ipsc->cAlphaArgs(10);
             Tank.SourceOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                        state.dataIPShortCut->cAlphaArgs(11),
+                                                                        s_ipsc->cAlphaArgs(11),
                                                                         ErrorsFound,
                                                                         DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterMixed,
-                                                                        state.dataIPShortCut->cAlphaArgs(1),
+                                                                        s_ipsc->cAlphaArgs(1),
                                                                         DataLoopNode::NodeFluidType::Water,
                                                                         DataLoopNode::ConnectionType::Outlet,
                                                                         NodeInputManager::CompFluidStream::Secondary,
                                                                         DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName2 = state.dataIPShortCut->cAlphaArgs(11);
+            Tank.OutletNodeName2 = s_ipsc->cAlphaArgs(11);
         }
 
         if (Tank.UseSidePlantLoc.loopSideNum == DataPlant::LoopSideLocation::Demand && Tank.SourceInletNode != 0) {
@@ -3622,7 +3568,8 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
     bool ErrorsFound = false;
     static constexpr std::string_view routineName = "getWaterTankStratifiedInput";
 
-    state.dataIPShortCut->cCurrentModuleObject = cStratifiedCWTankModuleObj; // 'ThermalStorage:ChilledWater:Stratified'
+    auto &s_ipsc = state.dataIPShortCut;
+    s_ipsc->cCurrentModuleObject = cStratifiedCWTankModuleObj; // 'ThermalStorage:ChilledWater:Stratified'
 
     for (int WaterThermalTankNum = state.dataWaterThermalTanks->numWaterHeaterMixed + state.dataWaterThermalTanks->numWaterHeaterStratified +
                                    state.dataWaterThermalTanks->numChilledWaterMixed + 1;
@@ -3633,33 +3580,33 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         int NumAlphas;
         int IOStat;
         state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                 state.dataIPShortCut->cCurrentModuleObject,
+                                                                 s_ipsc->cCurrentModuleObject,
                                                                  WaterThermalTankNum - (state.dataWaterThermalTanks->numWaterHeaterMixed +
                                                                                         state.dataWaterThermalTanks->numWaterHeaterStratified +
                                                                                         state.dataWaterThermalTanks->numChilledWaterMixed),
-                                                                 state.dataIPShortCut->cAlphaArgs,
+                                                                 s_ipsc->cAlphaArgs,
                                                                  NumAlphas,
-                                                                 state.dataIPShortCut->rNumericArgs,
+                                                                 s_ipsc->rNumericArgs,
                                                                  NumNums,
                                                                  IOStat,
-                                                                 state.dataIPShortCut->lNumericFieldBlanks,
-                                                                 state.dataIPShortCut->lAlphaFieldBlanks,
-                                                                 state.dataIPShortCut->cAlphaFieldNames,
-                                                                 state.dataIPShortCut->cNumericFieldNames);
+                                                                 s_ipsc->lNumericFieldBlanks,
+                                                                 s_ipsc->lAlphaFieldBlanks,
+                                                                 s_ipsc->cAlphaFieldNames,
+                                                                 s_ipsc->cNumericFieldNames);
 
-        ErrorObjectHeader eoh{routineName, state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)};
+        ErrorObjectHeader eoh{routineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)};
 
         GlobalNames::VerifyUniqueInterObjectName(state,
                                                  state.dataWaterThermalTanks->UniqueWaterThermalTankNames,
-                                                 state.dataIPShortCut->cAlphaArgs(1),
-                                                 state.dataIPShortCut->cCurrentModuleObject,
-                                                 state.dataIPShortCut->cAlphaFieldNames(1),
+                                                 s_ipsc->cAlphaArgs(1),
+                                                 s_ipsc->cCurrentModuleObject,
+                                                 s_ipsc->cAlphaFieldNames(1),
                                                  ErrorsFound);
 
         auto &Tank = state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum);
 
-        Tank.Name = state.dataIPShortCut->cAlphaArgs(1);
-        Tank.Type = state.dataIPShortCut->cCurrentModuleObject;
+        Tank.Name = s_ipsc->cAlphaArgs(1);
+        Tank.Type = s_ipsc->cCurrentModuleObject;
         Tank.WaterThermalTankType = DataPlant::PlantEquipmentType::ChilledWaterTankStratified;
 
         if ((Tank.water = Fluid::GetWater(state)) == nullptr) {
@@ -3670,7 +3617,7 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         Tank.IsChilledWaterTank = true;
         Tank.EndUseSubcategoryName = "Chilled Water Storage";
 
-        Tank.Volume = state.dataIPShortCut->rNumericArgs(1);
+        Tank.Volume = s_ipsc->rNumericArgs(1);
         if (Tank.Volume == DataSizing::AutoSize) {
             Tank.VolumeWasAutoSized = true;
         }
@@ -3678,25 +3625,25 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         Real64 rho = Tank.water->getDensity(state, Constant::InitConvTemp, routineName);
 
         Tank.Mass = Tank.Volume * rho;
-        Tank.Height = state.dataIPShortCut->rNumericArgs(2);
+        Tank.Height = s_ipsc->rNumericArgs(2);
         if (Tank.Height == DataSizing::AutoSize) {
             Tank.HeightWasAutoSized = true;
         }
 
-        Tank.Shape = static_cast<TankShape>(getEnumValue(TankShapeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(2))));
+        Tank.Shape = static_cast<TankShape>(getEnumValue(TankShapeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(2))));
         switch (Tank.Shape) {
         case TankShape::HorizCylinder:
         case TankShape::VertCylinder: {
             break;
         }
         case TankShape::Other: {
-            if (state.dataIPShortCut->rNumericArgs(3) > 0.0) {
-                Tank.Perimeter = state.dataIPShortCut->rNumericArgs(3);
+            if (s_ipsc->rNumericArgs(3) > 0.0) {
+                Tank.Perimeter = s_ipsc->rNumericArgs(3);
             } else {
                 ShowSevereError(state,
                                 format("{} = {}:  Tank Perimeter must be greater than zero for Tank Shape=OTHER",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1)));
                 ErrorsFound = true;
             }
             break;
@@ -3704,39 +3651,39 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         default: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Tank Shape entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(2)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(2)));
             Tank.Shape = TankShape::VertCylinder;
             ErrorsFound = true;
             break;
         }
         }
 
-        if (state.dataIPShortCut->rNumericArgs(6) > 0.0) {
-            Tank.TankTempLimit = state.dataIPShortCut->rNumericArgs(6);
+        if (s_ipsc->rNumericArgs(6) > 0.0) {
+            Tank.TankTempLimit = s_ipsc->rNumericArgs(6);
         } else {
             // default to just above freezing
             Tank.TankTempLimit = 1.0;
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(3)) {
-            ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(3));
+        if (s_ipsc->lAlphaFieldBlanks(3)) {
+            ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(3));
             ErrorsFound = true;
-        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(3))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(3), state.dataIPShortCut->cAlphaArgs(3));
+        } else if ((Tank.setptTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(3))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(3), s_ipsc->cAlphaArgs(3));
             ErrorsFound = true;
         }
 
-        if (state.dataIPShortCut->rNumericArgs(4) > 0.0) {
-            Tank.DeadBandDeltaTemp = state.dataIPShortCut->rNumericArgs(4);
+        if (s_ipsc->rNumericArgs(4) > 0.0) {
+            Tank.DeadBandDeltaTemp = s_ipsc->rNumericArgs(4);
         } else {
             // Default to very small number (however it can't be TINY or it will break the algorithm)
             Tank.DeadBandDeltaTemp = 0.0001;
         }
 
-        Tank.HeaterHeight1 = state.dataIPShortCut->rNumericArgs(5);
-        Tank.MaxCapacity = state.dataIPShortCut->rNumericArgs(7);
+        Tank.HeaterHeight1 = s_ipsc->rNumericArgs(5);
+        Tank.MaxCapacity = s_ipsc->rNumericArgs(7);
         if (Tank.MaxCapacity == DataSizing::AutoSize) {
             Tank.MaxCapacityWasAutoSized = true;
         }
@@ -3757,25 +3704,25 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         Tank.OnCycParaHeight = 0.0;
 
         Tank.AmbientTempIndicator =
-            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(4))));
+            static_cast<WTTAmbientTemp>(getEnumValue(TankAmbientTempNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(4))));
         switch (Tank.AmbientTempIndicator) {
 
         case WTTAmbientTemp::Schedule: {
-            if (state.dataIPShortCut->lAlphaFieldBlanks(5)) {
-                ShowSevereEmptyField(state, eoh, state.dataIPShortCut->cAlphaFieldNames(5));
+            if (s_ipsc->lAlphaFieldBlanks(5)) {
+                ShowSevereEmptyField(state, eoh, s_ipsc->cAlphaFieldNames(5));
                 ErrorsFound = true;
-            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(5))) == nullptr) {
-                ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(5), state.dataIPShortCut->cAlphaArgs(5));
+            } else if ((Tank.ambientTempSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(5))) == nullptr) {
+                ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(5), s_ipsc->cAlphaArgs(5));
                 ErrorsFound = true;
             }
         } break;
 
         case WTTAmbientTemp::TempZone: {
-            Tank.AmbientTempZone = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(6), state.dataHeatBal->Zone);
+            Tank.AmbientTempZone = Util::FindItemInList(s_ipsc->cAlphaArgs(6), state.dataHeatBal->Zone);
             if (Tank.AmbientTempZone == 0) {
-                ShowSevereError(state, format("Invalid, {} = {}", state.dataIPShortCut->cAlphaFieldNames(6), state.dataIPShortCut->cAlphaArgs(6)));
+                ShowSevereError(state, format("Invalid, {} = {}", s_ipsc->cAlphaFieldNames(6), s_ipsc->cAlphaArgs(6)));
                 ShowContinueError(state,
-                                  format("Entered in {} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                                  format("Entered in {} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state, "Zone was not found.");
                 ErrorsFound = true;
             }
@@ -3786,25 +3733,25 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         case WTTAmbientTemp::OutsideAir: {
             Tank.AmbientTempOutsideAirNode =
                 NodeInputManager::GetOnlySingleNode(state,
-                                                    state.dataIPShortCut->cAlphaArgs(7),
+                                                    s_ipsc->cAlphaArgs(7),
                                                     ErrorsFound,
                                                     DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterStratified,
-                                                    state.dataIPShortCut->cAlphaArgs(1),
+                                                    s_ipsc->cAlphaArgs(1),
                                                     DataLoopNode::NodeFluidType::Air,
                                                     DataLoopNode::ConnectionType::Inlet,
                                                     NodeInputManager::CompFluidStream::Primary,
                                                     DataLoopNode::ObjectIsNotParent);
-            if (!state.dataIPShortCut->lAlphaFieldBlanks(7)) {
+            if (!s_ipsc->lAlphaFieldBlanks(7)) {
                 if (!OutAirNodeManager::CheckOutAirNodeNumber(state, Tank.AmbientTempOutsideAirNode)) {
                     ShowSevereError(state,
-                                    format("Invalid, {} = {}", state.dataIPShortCut->cAlphaFieldNames(7), state.dataIPShortCut->cAlphaArgs(7)));
+                                    format("Invalid, {} = {}", s_ipsc->cAlphaFieldNames(7), s_ipsc->cAlphaArgs(7)));
                     ShowContinueError(state,
-                                      format("Entered in {} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                                      format("Entered in {} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                     ShowContinueError(state, "Outdoor Air Node not on OutdoorAir:NodeList or OutdoorAir:Node");
                     ErrorsFound = true;
                 }
             } else {
-                ShowSevereError(state, format("{} = {}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
+                ShowSevereError(state, format("{} = {}", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state, "An Ambient Outdoor Air Node name must be used when the Ambient Temperature Indicator is Outdoors.");
                 ErrorsFound = true;
             }
@@ -3814,16 +3761,16 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         default: {
             ShowSevereError(state,
                             format("{} = {}:  Invalid Ambient Temperature Indicator entered={}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1),
-                                   state.dataIPShortCut->cAlphaArgs(4)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1),
+                                   s_ipsc->cAlphaArgs(4)));
             ShowContinueError(state, "  Valid entries are Schedule, Zone, and Outdoors.");
             ErrorsFound = true;
             break;
         }
         }
 
-        Tank.SkinLossCoeff = state.dataIPShortCut->rNumericArgs(8);
+        Tank.SkinLossCoeff = s_ipsc->rNumericArgs(8);
         Tank.SkinLossFracToZone = 1.0;
         Tank.OffCycFlueLossCoeff = 0.0;
         Tank.OffCycFlueLossFracToZone = 0.0;
@@ -3831,77 +3778,77 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
         Tank.MassFlowRateMax = 0.0;
         Tank.flowRateSched = nullptr;
         Tank.useInletTempSched = nullptr;
-        Tank.UseEffectiveness = state.dataIPShortCut->rNumericArgs(9);
-        Tank.UseInletHeight = state.dataIPShortCut->rNumericArgs(10);
+        Tank.UseEffectiveness = s_ipsc->rNumericArgs(9);
+        Tank.UseInletHeight = s_ipsc->rNumericArgs(10);
 
         // default to always on
         Tank.sourceSideAvailSched = Sched::GetScheduleAlwaysOn(state);
         Tank.useSideAvailSched = Sched::GetScheduleAlwaysOn(state);
 
-        if (state.dataIPShortCut->rNumericArgs(10) == Constant::AutoCalculate) {
+        if (s_ipsc->rNumericArgs(10) == Constant::AutoCalculate) {
             Tank.UseInletHeight = Tank.Height; // top of tank
         }
         if (Tank.UseInletHeight > Tank.Height) {
             ShowSevereError(state,
                             format("{} = {}: Use inlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(10), state.dataIPShortCut->rNumericArgs(10)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(10), s_ipsc->rNumericArgs(10)));
             ErrorsFound = true;
         }
 
-        Tank.UseOutletHeight = state.dataIPShortCut->rNumericArgs(11);
+        Tank.UseOutletHeight = s_ipsc->rNumericArgs(11);
         if (Tank.UseOutletHeight > Tank.Height) {
             ShowSevereError(state,
                             format("{} = {}: Use outlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(11), state.dataIPShortCut->rNumericArgs(11)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(11), s_ipsc->rNumericArgs(11)));
             ErrorsFound = true;
         }
 
-        if ((state.dataIPShortCut->rNumericArgs(13) > 1) || (state.dataIPShortCut->rNumericArgs(13) <= 0)) {
+        if ((s_ipsc->rNumericArgs(13) > 1) || (s_ipsc->rNumericArgs(13) <= 0)) {
             ShowSevereError(state,
                             format("{} = {}:  Source Side Effectiveness is out of bounds (>0 to 1)",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
             ErrorsFound = true;
         }
-        Tank.SourceEffectiveness = state.dataIPShortCut->rNumericArgs(13);
+        Tank.SourceEffectiveness = s_ipsc->rNumericArgs(13);
 
-        Tank.SourceInletHeight = state.dataIPShortCut->rNumericArgs(14);
+        Tank.SourceInletHeight = s_ipsc->rNumericArgs(14);
         if (Tank.SourceInletHeight > Tank.Height) {
             ShowSevereError(state,
                             format("{} = {}: Source inlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(14), state.dataIPShortCut->rNumericArgs(14)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(14), s_ipsc->rNumericArgs(14)));
             ErrorsFound = true;
         }
 
-        Tank.SourceOutletHeight = state.dataIPShortCut->rNumericArgs(15);
-        if (state.dataIPShortCut->rNumericArgs(15) == Constant::AutoCalculate) {
+        Tank.SourceOutletHeight = s_ipsc->rNumericArgs(15);
+        if (s_ipsc->rNumericArgs(15) == Constant::AutoCalculate) {
             Tank.SourceOutletHeight = Tank.Height; // top of tank
         }
         if (Tank.SourceOutletHeight > Tank.Height) {
             ShowSevereError(state,
                             format("{} = {}: Source outlet is located higher than overall tank height.",
-                                   state.dataIPShortCut->cCurrentModuleObject,
-                                   state.dataIPShortCut->cAlphaArgs(1)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(2), state.dataIPShortCut->rNumericArgs(2)));
-            ShowContinueError(state, format("{} = {:.4R}", state.dataIPShortCut->cNumericFieldNames(15), state.dataIPShortCut->rNumericArgs(15)));
+                                   s_ipsc->cCurrentModuleObject,
+                                   s_ipsc->cAlphaArgs(1)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, format("{} = {:.4R}", s_ipsc->cNumericFieldNames(15), s_ipsc->rNumericArgs(15)));
             ErrorsFound = true;
         }
 
         Tank.StandAlone = false;
 
-        if (state.dataIPShortCut->lNumericFieldBlanks(12)) {
+        if (s_ipsc->lNumericFieldBlanks(12)) {
             Tank.UseDesignVolFlowRate = 0.0;
         } else {
-            Tank.UseDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(12);
+            Tank.UseDesignVolFlowRate = s_ipsc->rNumericArgs(12);
             if (Tank.UseDesignVolFlowRate == DataSizing::AutoSize) {
                 Tank.UseDesignVolFlowRateWasAutoSized = true;
             }
@@ -3909,69 +3856,69 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
 
         Tank.UseSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if (state.dataIPShortCut->lNumericFieldBlanks(16)) {
+        if (s_ipsc->lNumericFieldBlanks(16)) {
             Tank.SourceDesignVolFlowRate = 0.0;
         } else {
-            Tank.SourceDesignVolFlowRate = state.dataIPShortCut->rNumericArgs(16);
+            Tank.SourceDesignVolFlowRate = s_ipsc->rNumericArgs(16);
             if (Tank.SourceDesignVolFlowRate == DataSizing::AutoSize) {
                 Tank.SourceDesignVolFlowRateWasAutoSized = true;
             }
         }
 
-        Tank.SizingRecoveryTime = state.dataIPShortCut->rNumericArgs(17);
+        Tank.SizingRecoveryTime = s_ipsc->rNumericArgs(17);
 
         Tank.SrcSidePlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
 
-        if ((!state.dataIPShortCut->lAlphaFieldBlanks(8)) || (!state.dataIPShortCut->lAlphaFieldBlanks(9))) {
+        if ((!s_ipsc->lAlphaFieldBlanks(8)) || (!s_ipsc->lAlphaFieldBlanks(9))) {
             Tank.UseInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                    state.dataIPShortCut->cAlphaArgs(8),
+                                                                    s_ipsc->cAlphaArgs(8),
                                                                     ErrorsFound,
                                                                     DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterStratified,
-                                                                    state.dataIPShortCut->cAlphaArgs(1),
+                                                                    s_ipsc->cAlphaArgs(1),
                                                                     DataLoopNode::NodeFluidType::Water,
                                                                     DataLoopNode::ConnectionType::Inlet,
                                                                     NodeInputManager::CompFluidStream::Primary,
                                                                     DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName1 = state.dataIPShortCut->cAlphaArgs(8);
+            Tank.InletNodeName1 = s_ipsc->cAlphaArgs(8);
             Tank.UseOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                     state.dataIPShortCut->cAlphaArgs(9),
+                                                                     s_ipsc->cAlphaArgs(9),
                                                                      ErrorsFound,
                                                                      DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterStratified,
-                                                                     state.dataIPShortCut->cAlphaArgs(1),
+                                                                     s_ipsc->cAlphaArgs(1),
                                                                      DataLoopNode::NodeFluidType::Water,
                                                                      DataLoopNode::ConnectionType::Outlet,
                                                                      NodeInputManager::CompFluidStream::Primary,
                                                                      DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName1 = state.dataIPShortCut->cAlphaArgs(9);
+            Tank.OutletNodeName1 = s_ipsc->cAlphaArgs(9);
         }
 
-        if ((!state.dataIPShortCut->lAlphaFieldBlanks(11)) || (!state.dataIPShortCut->lAlphaFieldBlanks(12))) {
+        if ((!s_ipsc->lAlphaFieldBlanks(11)) || (!s_ipsc->lAlphaFieldBlanks(12))) {
             Tank.SourceInletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                       state.dataIPShortCut->cAlphaArgs(11),
+                                                                       s_ipsc->cAlphaArgs(11),
                                                                        ErrorsFound,
                                                                        DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterStratified,
-                                                                       state.dataIPShortCut->cAlphaArgs(1),
+                                                                       s_ipsc->cAlphaArgs(1),
                                                                        DataLoopNode::NodeFluidType::Water,
                                                                        DataLoopNode::ConnectionType::Inlet,
                                                                        NodeInputManager::CompFluidStream::Secondary,
                                                                        DataLoopNode::ObjectIsNotParent);
-            Tank.InletNodeName2 = state.dataIPShortCut->cAlphaArgs(11);
+            Tank.InletNodeName2 = s_ipsc->cAlphaArgs(11);
             Tank.SourceOutletNode = NodeInputManager::GetOnlySingleNode(state,
-                                                                        state.dataIPShortCut->cAlphaArgs(12),
+                                                                        s_ipsc->cAlphaArgs(12),
                                                                         ErrorsFound,
                                                                         DataLoopNode::ConnectionObjectType::ThermalStorageChilledWaterStratified,
-                                                                        state.dataIPShortCut->cAlphaArgs(1),
+                                                                        s_ipsc->cAlphaArgs(1),
                                                                         DataLoopNode::NodeFluidType::Water,
                                                                         DataLoopNode::ConnectionType::Outlet,
                                                                         NodeInputManager::CompFluidStream::Secondary,
                                                                         DataLoopNode::ObjectIsNotParent);
-            Tank.OutletNodeName2 = state.dataIPShortCut->cAlphaArgs(12);
+            Tank.OutletNodeName2 = s_ipsc->cAlphaArgs(12);
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(10)) {
+        if (s_ipsc->lAlphaFieldBlanks(10)) {
             Tank.useSideAvailSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((Tank.useSideAvailSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(10))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(10), state.dataIPShortCut->cAlphaArgs(10));
+        } else if ((Tank.useSideAvailSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(10))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(10), s_ipsc->cAlphaArgs(10));
             ErrorsFound = true;
         }
 
@@ -3979,25 +3926,25 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
             PlantUtilities::RegisterPlantCompDesignFlow(state, Tank.SourceInletNode, Tank.SourceDesignVolFlowRate);
         }
 
-        if (state.dataIPShortCut->lAlphaFieldBlanks(13)) {
+        if (s_ipsc->lAlphaFieldBlanks(13)) {
             Tank.sourceSideAvailSched = Sched::GetScheduleAlwaysOn(state);
-        } else if ((Tank.sourceSideAvailSched = Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(13))) == nullptr) {
-            ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(13), state.dataIPShortCut->cAlphaArgs(13));
+        } else if ((Tank.sourceSideAvailSched = Sched::GetSchedule(state, s_ipsc->cAlphaArgs(13))) == nullptr) {
+            ShowSevereItemNotFound(state, eoh, s_ipsc->cAlphaFieldNames(13), s_ipsc->cAlphaArgs(13));
             ErrorsFound = true;
         }
 
         // Validate inlet mode
         Tank.InletMode =
-            static_cast<InletPositionMode>(getEnumValue(InletPositionModeNamesUC, Util::makeUPPER(state.dataIPShortCut->cAlphaArgs(14))));
+            static_cast<InletPositionMode>(getEnumValue(InletPositionModeNamesUC, Util::makeUPPER(s_ipsc->cAlphaArgs(14))));
 
-        Tank.Nodes = state.dataIPShortCut->rNumericArgs(18);
-        Tank.AdditionalCond = state.dataIPShortCut->rNumericArgs(19);
+        Tank.Nodes = s_ipsc->rNumericArgs(18);
+        Tank.AdditionalCond = s_ipsc->rNumericArgs(19);
 
         Tank.AdditionalLossCoeff.allocate(Tank.Nodes);
         Tank.AdditionalLossCoeff = 0.0;
         for (int NodeNum = 1; NodeNum <= Tank.Nodes; ++NodeNum) {
             if (NumNums > 19 + NodeNum) {
-                Tank.AdditionalLossCoeff(NodeNum) = state.dataIPShortCut->rNumericArgs(19 + NodeNum);
+                Tank.AdditionalLossCoeff(NodeNum) = s_ipsc->rNumericArgs(19 + NodeNum);
             } else {
                 break;
             }
@@ -4007,8 +3954,8 @@ bool getWaterTankStratifiedInput(EnergyPlusData &state)
             ShowWarningError(
                 state,
                 format("{} = {}:  More Additional Loss Coefficients were entered than the number of nodes; extra coefficients will not be used",
-                       state.dataIPShortCut->cCurrentModuleObject,
-                       state.dataIPShortCut->cAlphaArgs(1)));
+                       s_ipsc->cCurrentModuleObject,
+                       s_ipsc->cAlphaArgs(1)));
         }
 
         Tank.SetupStratifiedNodes(state);
@@ -4037,6 +3984,8 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
     // Make sure refrigeration input is gotten before this input
     RefrigeratedCase::CheckRefrigerationInput(state);
 
+    auto &s_ipsc = state.dataIPShortCut;
+    
     if (state.dataWaterThermalTanks->getWaterThermalTankInputFlag) {
         state.dataWaterThermalTanks->numWaterHeaterMixed = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cMixedWHModuleObj);
         state.dataWaterThermalTanks->numWaterHeaterStratified =
@@ -4124,7 +4073,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
 
         //   Loop through all desuperheating coils and then search all water heaters for the tank connected to the desuperheating coil
         if (state.dataWaterThermalTanks->numWaterHeaterDesuperheater > 0) {
-            state.dataIPShortCut->cCurrentModuleObject = cCoilDesuperheater;
+            s_ipsc->cCurrentModuleObject = cCoilDesuperheater;
             for (int DesuperheaterNum = 1; DesuperheaterNum <= state.dataWaterThermalTanks->numWaterHeaterDesuperheater; ++DesuperheaterNum) {
                 auto &DesuperHtr = state.dataWaterThermalTanks->WaterHeaterDesuperheater(DesuperheaterNum);
                 for (int WtrHtrNum = 1; WtrHtrNum <= state.dataWaterThermalTanks->numWaterThermalTank; ++WtrHtrNum) {
@@ -4138,7 +4087,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
 
                     //         verify Desuperheater/tank source node connections
                     if (DesuperHtr.WaterInletNode != Tank.SourceOutletNode) {
-                        ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, DesuperHtr.Name));
+                        ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, DesuperHtr.Name));
                         ShowContinueError(state, "Desuperheater inlet node name does not match thermal tank source outlet node name.");
                         ShowContinueError(state,
                                           format("Desuperheater water inlet and outlet node names = {} and {}",
@@ -4152,7 +4101,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                     }
 
                     if (DesuperHtr.WaterOutletNode != Tank.SourceInletNode) {
-                        ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, DesuperHtr.Name));
+                        ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, DesuperHtr.Name));
                         ShowContinueError(state, "Desuperheater water outlet node name does not match thermal tank source inlet node name.");
                         ShowContinueError(state,
                                           format("Desuperheater water inlet and outlet node names = {} and {}",
@@ -4167,7 +4116,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                 }
 
                 if (DesuperHtr.WaterHeaterTankNum == 0) {
-                    ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, DesuperHtr.Name));
+                    ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, DesuperHtr.Name));
                     ShowContinueError(state, format(" Water heater tank = {} not found.", DesuperHtr.TankName));
                     ErrorsFound = true;
                 }
@@ -4185,10 +4134,10 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                 HeatPumpWaterHeaterData &HPWH = state.dataWaterThermalTanks->HPWaterHeater(HPWaterHeaterNum);
                 if (HPWaterHeaterNum <= NumPumpedCondenser) {
                     // Pumped Condenser
-                    state.dataIPShortCut->cCurrentModuleObject = cHPWHPumpedCondenser;
+                    s_ipsc->cCurrentModuleObject = cHPWHPumpedCondenser;
                 } else {
                     // Wrapped Condenser
-                    state.dataIPShortCut->cCurrentModuleObject = cHPWHWrappedCondenser;
+                    s_ipsc->cCurrentModuleObject = cHPWHWrappedCondenser;
                 }
 
                 // find the tank associated with the heat pump water heater and change its %TYPE to HEAT PUMP:WATER HEATER
@@ -4213,7 +4162,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                         HPWH.TankType = Tank.Type;
                         HPWH.HPWHTankType = Tank.WaterThermalTankType;
                     } else {
-                        ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                        ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                         ShowContinueError(state, format("Invalid water heater tank type = {}", Tank.Type));
                         ErrorsFound = true;
                     }
@@ -4223,14 +4172,14 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                         BranchNodeConnections::SetUpCompSets(state,
                                                              HPWH.Type,
                                                              HPWH.Name,
-                                                             HPWH.DXCoilType,
+                                                             HVAC::coilTypeNames[(int)HPWH.DXCoilType],
                                                              HPWH.DXCoilName + " Water Coil",
                                                              HPWH.InletNodeName1,
                                                              HPWH.OutletNodeName1,
                                                              "HPWH To Coil");
                     } else {
                         BranchNodeConnections::SetUpCompSets(
-                            state, HPWH.Type, HPWH.Name, HPWH.DXCoilType, HPWH.DXCoilName, HPWH.InletNodeName1, HPWH.OutletNodeName1, "HPWH To Coil");
+                            state, HPWH.Type, HPWH.Name, HVAC::coilTypeNames[(int)HPWH.DXCoilType], HPWH.DXCoilName, HPWH.InletNodeName1, HPWH.OutletNodeName1, "HPWH To Coil");
                     }
                     BranchNodeConnections::SetUpCompSets(
                         state, HPWH.Type, HPWH.Name, HPWH.TankType, HPWH.TankName, HPWH.OutletNodeName1, HPWH.InletNodeName1, "HPWH To Tank");
@@ -4238,7 +4187,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                     // If WaterHeaterMixed: do not allow modulating control for HPWH's (i.e. modulating control usually used for tankless WH's)
                     if ((Tank.WaterThermalTankType == DataPlant::PlantEquipmentType::WtrHeaterMixed) &&
                         (Tank.ControlType == HeaterControlMode::Modulate)) {
-                        ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                        ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                         ShowContinueError(state, format("Heater Control Type for {} = {} must be CYCLE.", Tank.Type, Tank.Name));
                         ErrorsFound = true;
                     }
@@ -4251,7 +4200,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                         ShowSevereError(
                             state,
                             format("{} = {}and Coil:WaterHeating:Desuperheater = {}:  cannot be connected to the same water heater tank = {}",
-                                   state.dataIPShortCut->cCurrentModuleObject,
+                                   s_ipsc->cCurrentModuleObject,
                                    HPWH.Name,
                                    state.dataWaterThermalTanks->WaterHeaterDesuperheater(CheckWaterHeaterNum).Name,
                                    Tank.Name));
@@ -4261,7 +4210,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                     if (Tank.SourceEffectiveness <= 0.0) {
                         ShowSevereError(state,
                                         format("{} = {}:  Invalid source side effectiveness for heat pump water heater = {:.3T}",
-                                               state.dataIPShortCut->cCurrentModuleObject,
+                                               s_ipsc->cCurrentModuleObject,
                                                HPWH.Name,
                                                Tank.SourceEffectiveness));
                         ShowContinueError(state, " water heater source effectiveness will default to 1.0 and simulation continues.");
@@ -4311,7 +4260,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                     if (Tank.UseInletNode == 0 && Tank.UseOutletNode == 0) HPWH.StandAlone = true;
 
                     if (HPWH.WHUseInletNode != Tank.UseInletNode || HPWH.WHUseOutletNode != Tank.UseOutletNode) {
-                        ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                        ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                         ShowContinueError(state,
                                           format("Heat pump water heater tank use side inlet and outlet node names must match the use side inlet and "
                                                  "outlet node names for water heater tank = {}: {}",
@@ -4334,7 +4283,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
 
                     // verify HP/tank source node connections
                     if (HPWH.CondWaterInletNode != Tank.SourceOutletNode) {
-                        ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                        ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                         ShowContinueError(state,
                                           "Heat Pump condenser water inlet node name does not match water heater tank source outlet node name.");
                         ShowContinueError(
@@ -4348,7 +4297,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                     }
 
                     if (HPWH.CondWaterOutletNode != Tank.SourceInletNode) {
-                        ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                        ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                         ShowContinueError(state,
                                           "Heat Pump condenser water outlet node name does not match water heater tank source inlet node name.");
                         ShowContinueError(
@@ -4365,7 +4314,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                     if (HPWH.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterWrapped) {
                         // make sure the top of the condenser is not above the tank height.
                         if (HPWH.WrappedCondenserTopLocation > Tank.Height) {
-                            ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                            ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                             ShowContinueError(state, "The height of the top of the wrapped condenser is greater than the height of the tank.");
                             ErrorsFound = true;
                         }
@@ -4389,7 +4338,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                                 break;
                             } // EquipmentTypeNum
                             if (!FoundTankInList) {
-                                ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                                ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                                 ShowContinueError(state,
                                                   "Heat pump water heater type and name must be listed in the correct "
                                                   "ZoneHVAC:EquipmentList object when Inlet Air Configuration is equal to "
@@ -4399,7 +4348,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             //                     check that tank has lower priority than all other non-HPWH objects in Zone
                             //                     Equipment List
                             for (int EquipmentTypeNum = 1; EquipmentTypeNum <= zoneEquipList.NumOfEquipTypes; ++EquipmentTypeNum) {
-                                if (Util::SameString(zoneEquipList.EquipTypeName(EquipmentTypeNum), state.dataIPShortCut->cCurrentModuleObject))
+                                if (Util::SameString(zoneEquipList.EquipTypeName(EquipmentTypeNum), s_ipsc->cCurrentModuleObject))
                                     continue;
                                 if (TankCoolingPriority > zoneEquipList.CoolingPriority(EquipmentTypeNum) ||
                                     TankHeatingPriority > zoneEquipList.HeatingPriority(EquipmentTypeNum)) {
@@ -4407,7 +4356,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                                 }
                             } // EquipmentTypeNum
                             if (TankNotLowestPriority && FoundTankInList) {
-                                ShowWarningError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                                ShowWarningError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                                 ShowContinueError(state,
                                                   "Heat pump water heaters should be simulated first, before other space "
                                                   "conditioning equipment.");
@@ -4416,7 +4365,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                                                   "not 1 in the ZoneHVAC:EquipmentList.");
                             }
                         } else {
-                            ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                            ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                             ShowContinueError(state,
                                               "ZoneHVAC:EquipmentList and ZoneHVAC:EquipmentConnections objects are required when Inlet Air "
                                               "Configuration is either ZoneAirOnly or ZoneAndOutdoorAir.");
@@ -4429,7 +4378,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                         // Nodal heat distribution fraction for stratified tank wrapped condensers
                         if (HPWH.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterWrapped) {
                             if (Tank.Shape == TankShape::HorizCylinder) {
-                                ShowWarningError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                                ShowWarningError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                                 ShowContinueError(state, "A wrapped condenser HPWH model should not be used with a horizontal stratified tank.");
                                 ShowContinueError(
                                     state, "Ignoring condenser location and distributing heat evenly throughout the tank. Simulation continues.");
@@ -4498,12 +4447,12 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
 
                         // Make sure the control sensor locations are in the tank
                         if (HPWH.ControlSensor1Height < 0.0 || HPWH.ControlSensor1Height > TankHeight) {
-                            ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                            ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                             ShowContinueError(state, "Control Sensor 1 is located outside the tank.");
                             ErrorsFound = true;
                         }
                         if (HPWH.ControlSensor2Height < 0.0 || HPWH.ControlSensor2Height > TankHeight) {
-                            ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                            ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                             ShowContinueError(state, "Control Sensor 2 is located outside the tank.");
                             ErrorsFound = true;
                         }
@@ -4536,7 +4485,7 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                 } // DO CheckWaterHeaterNum = 1, NumWaterHeater
 
                 if (!HPWH.FoundTank) {
-                    ShowSevereError(state, format("{} = {}:", state.dataIPShortCut->cCurrentModuleObject, HPWH.Name));
+                    ShowSevereError(state, format("{} = {}:", s_ipsc->cCurrentModuleObject, HPWH.Name));
                     ShowContinueError(state, format("Water heater tank object not found = {}, {}", HPWH.TankType, HPWH.TankName));
                     ErrorsFound = true;
                 }
@@ -4545,9 +4494,9 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
         }
 
         // Get water heater sizing input.
-        state.dataIPShortCut->cCurrentModuleObject = "WaterHeater:Sizing";
+        s_ipsc->cCurrentModuleObject = "WaterHeater:Sizing";
         state.dataWaterThermalTanks->numWaterHeaterSizing =
-            state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataIPShortCut->cCurrentModuleObject);
+            state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, s_ipsc->cCurrentModuleObject);
 
         if (state.dataWaterThermalTanks->numWaterHeaterSizing > 0) {
 
@@ -4556,74 +4505,74 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                 int NumNums;
                 int IOStat;
                 state.dataInputProcessing->inputProcessor->getObjectItem(state,
-                                                                         state.dataIPShortCut->cCurrentModuleObject,
+                                                                         s_ipsc->cCurrentModuleObject,
                                                                          WHsizingNum,
-                                                                         state.dataIPShortCut->cAlphaArgs,
+                                                                         s_ipsc->cAlphaArgs,
                                                                          NumAlphas,
-                                                                         state.dataIPShortCut->rNumericArgs,
+                                                                         s_ipsc->rNumericArgs,
                                                                          NumNums,
                                                                          IOStat);
 
                 // find which water heater this object is for
-                int WaterThermalTankNum = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(1), state.dataWaterThermalTanks->WaterThermalTank);
+                int WaterThermalTankNum = Util::FindItemInList(s_ipsc->cAlphaArgs(1), state.dataWaterThermalTanks->WaterThermalTank);
                 if (WaterThermalTankNum == 0) {
                     // did not match name throw warning.
                     ShowSevereError(state,
                                     format("{} object name: {} does not match any of the water heaters defined in the file",
-                                           state.dataIPShortCut->cCurrentModuleObject,
-                                           state.dataIPShortCut->cAlphaArgs(1)));
+                                           s_ipsc->cCurrentModuleObject,
+                                           s_ipsc->cAlphaArgs(1)));
                     ErrorsFound = true;
                     continue;
                 } else { // we have a match
                     // store the sizing data in "sizing" nested derived type for the correct water heater
 
-                    if (Util::SameString(state.dataIPShortCut->cAlphaArgs(2), "PeakDraw")) {
+                    if (Util::SameString(s_ipsc->cAlphaArgs(2), "PeakDraw")) {
                         state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.DesignMode = SizingMode::PeakDraw;
-                    } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(2), "ResidentialHUD-FHAMinimum")) {
+                    } else if (Util::SameString(s_ipsc->cAlphaArgs(2), "ResidentialHUD-FHAMinimum")) {
                         state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.DesignMode = SizingMode::ResidentialMin;
-                    } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(2), "PerPerson")) {
+                    } else if (Util::SameString(s_ipsc->cAlphaArgs(2), "PerPerson")) {
                         state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.DesignMode = SizingMode::PerPerson;
-                    } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(2), "PerFloorArea")) {
+                    } else if (Util::SameString(s_ipsc->cAlphaArgs(2), "PerFloorArea")) {
                         state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.DesignMode = SizingMode::PerFloorArea;
-                    } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(2), "PerUnit")) {
+                    } else if (Util::SameString(s_ipsc->cAlphaArgs(2), "PerUnit")) {
                         state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.DesignMode = SizingMode::PerUnit;
-                    } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(2), "PerSolarCollectorArea")) {
+                    } else if (Util::SameString(s_ipsc->cAlphaArgs(2), "PerSolarCollectorArea")) {
                         state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.DesignMode = SizingMode::PerSolarColArea;
                     } else {
                         // wrong design mode entered, throw error
                         ShowSevereError(state,
                                         format("{} object named: {} contains an incorrect Design Mode of: {}",
-                                               state.dataIPShortCut->cCurrentModuleObject,
-                                               state.dataIPShortCut->cAlphaArgs(1),
-                                               state.dataIPShortCut->cAlphaArgs(2)));
+                                               s_ipsc->cCurrentModuleObject,
+                                               s_ipsc->cAlphaArgs(1),
+                                               s_ipsc->cAlphaArgs(2)));
                         ErrorsFound = true;
                     }
 
-                    state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankDrawTime = state.dataIPShortCut->rNumericArgs(1);
-                    state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryTime = state.dataIPShortCut->rNumericArgs(2);
+                    state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankDrawTime = s_ipsc->rNumericArgs(1);
+                    state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryTime = s_ipsc->rNumericArgs(2);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NominalVolForSizingDemandSideFlow =
-                        state.dataIPShortCut->rNumericArgs(3);
+                        s_ipsc->rNumericArgs(3);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfBedrooms =
-                        int(state.dataIPShortCut->rNumericArgs(4));
+                        int(s_ipsc->rNumericArgs(4));
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfBathrooms =
-                        int(state.dataIPShortCut->rNumericArgs(5));
+                        int(s_ipsc->rNumericArgs(5));
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankCapacityPerPerson =
-                        state.dataIPShortCut->rNumericArgs(6);
+                        s_ipsc->rNumericArgs(6);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryCapacityPerPerson =
-                        state.dataIPShortCut->rNumericArgs(7);
+                        s_ipsc->rNumericArgs(7);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankCapacityPerArea =
-                        state.dataIPShortCut->rNumericArgs(8);
+                        s_ipsc->rNumericArgs(8);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryCapacityPerArea =
-                        state.dataIPShortCut->rNumericArgs(9);
-                    state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfUnits = state.dataIPShortCut->rNumericArgs(10);
+                        s_ipsc->rNumericArgs(9);
+                    state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfUnits = s_ipsc->rNumericArgs(10);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankCapacityPerUnit =
-                        state.dataIPShortCut->rNumericArgs(11);
+                        s_ipsc->rNumericArgs(11);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryCapacityPerUnit =
-                        state.dataIPShortCut->rNumericArgs(12);
+                        s_ipsc->rNumericArgs(12);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankCapacityPerCollectorArea =
-                        state.dataIPShortCut->rNumericArgs(13);
+                        s_ipsc->rNumericArgs(13);
                     state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.HeightAspectRatio =
-                        state.dataIPShortCut->rNumericArgs(14);
+                        s_ipsc->rNumericArgs(14);
 
                     switch (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.DesignMode) {
 
@@ -4635,16 +4584,16 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                         if (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankDrawTime <= 0.0) {
                             ShowSevereError(state,
                                             format("{}, named {}, design mode set to Peak Draw but needs a positive value for tank draw time",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         // constrain crazy sizes by limiting to 10 years or 8760*10
                         if (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankDrawTime > 87600.0) {
                             ShowWarningError(state,
                                              format("{}, named {},  has input with an unreasonably large Tank Draw Time, more than 10 years",
-                                                    state.dataIPShortCut->cCurrentModuleObject,
-                                                    state.dataIPShortCut->cAlphaArgs(1)));
+                                                    s_ipsc->cCurrentModuleObject,
+                                                    s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         // if both volume and demand side flow connections are autosized, must be a good NominalVolForSizingDemandSideFlow
@@ -4654,8 +4603,8 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             if (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NominalVolForSizingDemandSideFlow <= 0.0) {
                                 ShowWarningError(state,
                                                  format("{}, named {} needs a value for Nominal Tank Volume for Autosizing Plant Connections",
-                                                        state.dataIPShortCut->cCurrentModuleObject,
-                                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                                        s_ipsc->cCurrentModuleObject,
+                                                        s_ipsc->cAlphaArgs(1)));
                                 ErrorsFound = true;
                             }
                         }
@@ -4665,8 +4614,8 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             if (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NominalVolForSizingDemandSideFlow <= 0.0) {
                                 ShowWarningError(state,
                                                  format("{}, named {} needs a value for Nominal Tank Volume for Autosizing Plant Connections",
-                                                        state.dataIPShortCut->cCurrentModuleObject,
-                                                        state.dataIPShortCut->cAlphaArgs(1)));
+                                                        s_ipsc->cCurrentModuleObject,
+                                                        s_ipsc->cAlphaArgs(1)));
                                 ErrorsFound = true;
                             }
                         }
@@ -4678,15 +4627,15 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                         if (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfBedrooms < 1) {
                             ShowSevereError(state,
                                             format("{}, named {}, mode needs at least one bedroom",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         if (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfBedrooms > 10) {
                             ShowWarningError(state,
                                              format("{}, named {}, probably has too many bedrooms for the selected design mode",
-                                                    state.dataIPShortCut->cCurrentModuleObject,
-                                                    state.dataIPShortCut->cAlphaArgs(1)));
+                                                    s_ipsc->cCurrentModuleObject,
+                                                    s_ipsc->cAlphaArgs(1)));
                         }
 
                         break;
@@ -4697,8 +4646,8 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankCapacityPerPerson <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerPerson mode needs positive value input for storage capacity per person",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
 
@@ -4706,8 +4655,8 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryCapacityPerPerson <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerPerson mode needs positive value input for recovery capacity per person",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
 
@@ -4718,16 +4667,16 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankCapacityPerArea <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerArea mode needs positive value input for storage capacity per floor area",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         if ((state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).MaxCapacityWasAutoSized) &&
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryCapacityPerArea <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerArea mode needs positive value input for recovery capacity per floor area",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
 
@@ -4738,32 +4687,32 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.TankCapacityPerUnit <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerUnit mode needs positive value input for storage capacity per unit",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         if ((state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).VolumeWasAutoSized) &&
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfUnits <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerUnit mode needs positive value input for number of units",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         if ((state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).MaxCapacityWasAutoSized) &&
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.RecoveryCapacityPerUnit <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerUnit mode needs positive value input for recovery capacity per unit",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         if ((state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).MaxCapacityWasAutoSized) &&
                             (state.dataWaterThermalTanks->WaterThermalTank(WaterThermalTankNum).Sizing.NumberOfUnits <= 0.0)) {
                             ShowSevereError(state,
                                             format("{}, named {}, PerUnit mode needs positive value input for number of units",
-                                                   state.dataIPShortCut->cCurrentModuleObject,
-                                                   state.dataIPShortCut->cAlphaArgs(1)));
+                                                   s_ipsc->cCurrentModuleObject,
+                                                   s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         break;
@@ -4774,8 +4723,8 @@ bool GetWaterThermalTankInput(EnergyPlusData &state)
                             ShowSevereError(
                                 state,
                                 format("{}, named {}, PerSolarCollectorArea mode needs positive value input for storage capacity per collector area",
-                                       state.dataIPShortCut->cCurrentModuleObject,
-                                       state.dataIPShortCut->cAlphaArgs(1)));
+                                       s_ipsc->cCurrentModuleObject,
+                                       s_ipsc->cAlphaArgs(1)));
                             ErrorsFound = true;
                         }
                         break;
@@ -6348,31 +6297,30 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
     // initialize HPWHs each iteration
     if (this->HeatPumpNum > 0) {
 
-        int HPNum = this->HeatPumpNum;
-
+        auto &hpwh = state.dataWaterThermalTanks->HPWaterHeater(this->HeatPumpNum);
         if (this->MyHPSizeFlag) {
             //     autosize info must be calculated in GetWaterThermalTankInputFlag for use in StandardRating procedure
             //       (called at end of GetWaterThermalTankInputFlag)
             //     report autosizing information here (must be done after GetWaterThermalTankInputFlag is complete)
-            if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).WaterFlowRateAutoSized &&
+            if (hpwh.WaterFlowRateAutoSized &&
                 (state.dataPlnt->PlantFirstSizesOkayToReport || !state.dataGlobal->AnyPlantInModel || this->AlreadyRated)) {
                 BaseSizer::reportSizerOutput(state,
-                                             state.dataWaterThermalTanks->HPWaterHeater(HPNum).Type,
-                                             state.dataWaterThermalTanks->HPWaterHeater(HPNum).Name,
+                                             hpwh.Type,
+                                             hpwh.Name,
                                              "Condenser water flow rate [m3/s]",
-                                             state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingWaterFlowRate);
+                                             hpwh.OperatingWaterFlowRate);
             }
-            if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).AirFlowRateAutoSized &&
+            if (hpwh.AirFlowRateAutoSized &&
                 (state.dataPlnt->PlantFirstSizesOkayToReport || !state.dataGlobal->AnyPlantInModel || this->AlreadyRated)) {
                 BaseSizer::reportSizerOutput(state,
-                                             state.dataWaterThermalTanks->HPWaterHeater(HPNum).Type,
-                                             state.dataWaterThermalTanks->HPWaterHeater(HPNum).Name,
+                                             hpwh.Type,
+                                             hpwh.Name,
                                              "Evaporator air flow rate [m3/s]",
-                                             state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingAirFlowRate);
+                                             hpwh.OperatingAirFlowRate);
             }
-            state.dataSize->DataNonZoneNonAirloopValue = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingAirFlowRate;
-            state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingAirMassFlowRate =
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingAirFlowRate * state.dataEnvrn->StdRhoAir;
+            state.dataSize->DataNonZoneNonAirloopValue = hpwh.OperatingAirFlowRate;
+            hpwh.OperatingAirMassFlowRate =
+                hpwh.OperatingAirFlowRate * state.dataEnvrn->StdRhoAir;
             if (state.dataSize->CurZoneEqNum > 0) {
                 ZoneEqSizing(state.dataSize->CurZoneEqNum).CoolingAirFlow = true;
                 ZoneEqSizing(state.dataSize->CurZoneEqNum).CoolingAirVolFlow = state.dataSize->DataNonZoneNonAirloopValue;
@@ -6380,19 +6328,19 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
             if (state.dataPlnt->PlantFirstSizesOkayToReport || !state.dataGlobal->AnyPlantInModel || this->AlreadyRated) this->MyHPSizeFlag = false;
         }
 
-        int HPAirInletNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatPumpAirInletNode;
-        int HPAirOutletNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatPumpAirOutletNode;
-        int OutdoorAirNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutsideAirNode;
-        int ExhaustAirNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).ExhaustAirNode;
-        int HPWaterInletNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).CondWaterInletNode;
-        int HPWaterOutletNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).CondWaterOutletNode;
-        int InletAirMixerNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirMixerNode;
-        int OutletAirSplitterNode = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutletAirSplitterNode;
+        int HPAirInletNode = hpwh.HeatPumpAirInletNode;
+        int HPAirOutletNode = hpwh.HeatPumpAirOutletNode;
+        int OutdoorAirNode = hpwh.OutsideAirNode;
+        int ExhaustAirNode = hpwh.ExhaustAirNode;
+        int HPWaterInletNode = hpwh.CondWaterInletNode;
+        int HPWaterOutletNode = hpwh.CondWaterOutletNode;
+        int InletAirMixerNode = hpwh.InletAirMixerNode;
+        int OutletAirSplitterNode = hpwh.OutletAirSplitterNode;
 
-        switch (state.dataWaterThermalTanks->HPWaterHeater(HPNum).CrankcaseTempIndicator) {
+        switch (hpwh.CrankcaseTempIndicator) {
         case CrankcaseHeaterControlTemp::Zone: {
             state.dataHVACGlobal->HPWHCrankcaseDBTemp =
-                state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataWaterThermalTanks->HPWaterHeater(HPNum).AmbientTempZone).MAT;
+                state.dataZoneTempPredictorCorrector->zoneHeatBalance(hpwh.AmbientTempZone).MAT;
             break;
         }
         case CrankcaseHeaterControlTemp::Outdoors: {
@@ -6400,7 +6348,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
             break;
         }
         case CrankcaseHeaterControlTemp::Schedule: {
-            state.dataHVACGlobal->HPWHCrankcaseDBTemp = state.dataWaterThermalTanks->HPWaterHeater(HPNum).crankcaseTempSched->getCurrentVal();
+            state.dataHVACGlobal->HPWHCrankcaseDBTemp = hpwh.crankcaseTempSched->getCurrentVal();
             break;
         }
         default:
@@ -6408,17 +6356,17 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
         }
 
         //   initialize HPWH report variables to 0 and set tank inlet node equal to outlet node
-        state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWaterHeaterSensibleCapacity = 0.0;
-        state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWaterHeaterLatentCapacity = 0.0;
+        hpwh.HPWaterHeaterSensibleCapacity = 0.0;
+        hpwh.HPWaterHeaterLatentCapacity = 0.0;
         this->SourceMassFlowRate = 0.0;
-        state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatingPLR = 0.0;
+        hpwh.HeatingPLR = 0.0;
         this->SourceInletTemp = this->SourceOutletTemp;
 
         //   determine HPWH inlet air conditions based on inlet air configuration (Zone, ZoneAndOA, OutdoorAir, or Schedule)
         Real64 HPInletDryBulbTemp = 0.0;
         Real64 HPInletHumRat = 0.0;
         Real64 HPInletRelHum;
-        switch (state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirConfiguration) {
+        switch (hpwh.InletAirConfiguration) {
         case WTTAmbientTemp::TempZone: {
             state.dataWaterThermalTanks->mixerInletAirSchedule = 0.0;
             HPInletDryBulbTemp = state.dataLoopNodes->Node(HPAirInletNode).Temp;
@@ -6426,10 +6374,10 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
             break;
         }
         case WTTAmbientTemp::ZoneAndOA: {
-            if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).inletAirMixerSched != nullptr) {
+            if (hpwh.inletAirMixerSched != nullptr) {
                 //         schedule values are checked for boundary of 0 and 1 in GetWaterThermalTankInputFlag
                 state.dataWaterThermalTanks->mixerInletAirSchedule =
-                    state.dataWaterThermalTanks->HPWaterHeater(HPNum).inletAirMixerSched->getCurrentVal();
+                    hpwh.inletAirMixerSched->getCurrentVal();
             } else {
                 state.dataWaterThermalTanks->mixerInletAirSchedule = 0.0;
             }
@@ -6447,8 +6395,8 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
             break;
         }
         case WTTAmbientTemp::Schedule: {
-            HPInletDryBulbTemp = state.dataWaterThermalTanks->HPWaterHeater(HPNum).ambientTempSched->getCurrentVal();
-            HPInletRelHum = state.dataWaterThermalTanks->HPWaterHeater(HPNum).ambientRHSched->getCurrentVal();
+            HPInletDryBulbTemp = hpwh.ambientTempSched->getCurrentVal();
+            HPInletRelHum = hpwh.ambientRHSched->getCurrentVal();
             HPInletHumRat = Psychrometrics::PsyWFnTdbRhPb(state, HPInletDryBulbTemp, HPInletRelHum, state.dataEnvrn->OutBaroPress, RoutineName);
             state.dataLoopNodes->Node(HPAirInletNode).Temp = HPInletDryBulbTemp;
             state.dataLoopNodes->Node(HPAirInletNode).HumRat = HPInletHumRat;
@@ -6462,7 +6410,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
             break;
         }
 
-        state.dataWaterThermalTanks->mdotAir = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingAirMassFlowRate;
+        state.dataWaterThermalTanks->mdotAir = hpwh.OperatingAirMassFlowRate;
 
         //   set up initial conditions on nodes
         if (InletAirMixerNode > 0) {
@@ -6493,13 +6441,13 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
         if (OutletAirSplitterNode > 0) state.dataLoopNodes->Node(OutletAirSplitterNode).MassFlowRate = 0.0;
         // these are water nodes are not managed by plant. the HP connects
         // directly to the WH without using plant.
-        if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped) {
+        if (hpwh.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped) {
             state.dataLoopNodes->Node(HPWaterInletNode).MassFlowRate = 0.0;
             state.dataLoopNodes->Node(HPWaterOutletNode).MassFlowRate = 0.0;
         }
 
         //   set the max mass flow rate for outdoor fans
-        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanOutletNode).MassFlowRateMax =
+        state.dataLoopNodes->Node(hpwh.FanOutletNode).MassFlowRateMax =
             state.dataWaterThermalTanks->mdotAir;
 
         //   Curve objects in DXCoils::CalcHPWHDXCoil will use inlet conditions to HPWH not inlet air conditions to DX Coil
@@ -6509,21 +6457,19 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
             Psychrometrics::PsyTwbFnTdbWPb(state, state.dataHVACGlobal->HPWHInletDBTemp, HPInletHumRat, state.dataEnvrn->OutBaroPress);
 
         // initialize flow rates at speed levels for variable-speed HPWH
-        if ((state.dataWaterThermalTanks->HPWaterHeater(HPNum).bIsIHP) &&
-            (0 == state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed)) // use SCWH coil represents
+        if ((hpwh.bIsIHP) &&
+            (0 == hpwh.NumofSpeed)) // use SCWH coil represents
         {
-            IntegratedHeatPump::SizeIHP(state, state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum); //
+            IntegratedHeatPump::SizeIHP(state, hpwh.DXCoilNum); //
             // IntegratedHeatPump::SimIHP(modBlankString, HPWaterHeater(HPNum).DXCoilNum,
             //    0, EMP1, EMP2, EMP3, 0, 0.0, 1, 0.0, 0.0, 0.0, false, 0.0); //conduct the sizing operation in the IHP
-            int VSCoilID = state.dataIntegratedHP->IntegratedHeatPumps(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).SCWHCoilIndex;
-            state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).NumOfSpeeds;
+            int VSCoilID = state.dataIntegratedHP->IntegratedHeatPumps(hpwh.DXCoilNum).SCWHCoilNum;
+            hpwh.NumofSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).NumOfSpeeds;
 
-        } else if (Util::SameString(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilType,
-                                    "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed") &&
-                   (state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed == 0)) {
+        } else if (hpwh.DXCoilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed &&
+                   hpwh.NumofSpeed == 0) {
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      std::string(),
-                                                      state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
+                                                      hpwh.DXCoilNum,
                                                       HVAC::FanOp::Invalid, // Invalid instead of off?
                                                       HVAC::CompressorOp::Off,
                                                       0.0,
@@ -6532,93 +6478,77 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA
                                                       0.0,
                                                       0.0,
                                                       0.0); // conduct the sizing operation in the VS WSHP
-            int VSCoilID = state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum;
-            state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).NumOfSpeeds;
+            hpwh.NumofSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(hpwh.DXCoilNum).NumOfSpeeds;
             // below pass the flow rates from the VS coil to the water heater object
         }
 
-        if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed > 0) {
-            int VSCoilID;
-            if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).bIsIHP)
-                VSCoilID = state.dataIntegratedHP->IntegratedHeatPumps(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).SCWHCoilIndex;
-            else
-                VSCoilID = state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum;
-
+        if (hpwh.NumofSpeed > 0) {
+            int VSCoilID = (hpwh.bIsIHP) ? state.dataIntegratedHP->IntegratedHeatPumps(hpwh.DXCoilNum).SCWHCoilNum : hpwh.DXCoilNum;
+            auto &vsCoil = state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID);
             // scale air flow rates
-            Real64 MulSpeedFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).RatedAirVolFlowRate /
-                                       state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).MSRatedAirVolFlowRate(
-                                           state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).NormSpedLevel);
-            for (int Iter = 1; Iter <= state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed; ++Iter) {
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(Iter) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).MSRatedAirVolFlowRate(Iter) * MulSpeedFlowScale;
+            Real64 MulSpeedFlowScale = vsCoil.RatedAirVolFlowRate /
+                                       vsCoil.MSRatedAirVolFlowRate(
+                                           vsCoil.NormSpedLevel);
+            for (int Iter = 1; Iter <= hpwh.NumofSpeed; ++Iter) {
+                hpwh.HPWHAirVolFlowRate(Iter) =
+                    vsCoil.MSRatedAirVolFlowRate(Iter) * MulSpeedFlowScale;
             }
 
             // check fan flow rate, should be larger than the max flow rate of the VS coil
-            Real64 FanVolFlow = state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->maxAirFlowRate;
+            Real64 FanVolFlow = state.dataFans->fans(hpwh.FanNum)->maxAirFlowRate;
 
-            if (FanVolFlow < state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(
-                                 state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed)) { // but this is the not the scaled mas flow
+            if (FanVolFlow < hpwh.HPWHAirVolFlowRate(
+                                 hpwh.NumofSpeed)) { // but this is the not the scaled mas flow
                 // if ( FanVolFlow  < HPWaterHeater( HPNum ).HPWHAirVolFlowRate( HPWaterHeater( HPNum ).NumofSpeed ) ) {
 
                 ShowWarningError(state,
                                  format("InitWaterThermalTank: -air flow rate = {:.7T} in fan object  is less than the MSHP system air flow rate "
                                         "when waterheating is required({:.7T}).",
                                         FanVolFlow,
-                                        state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(
-                                            state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed)));
+                                        hpwh.HPWHAirVolFlowRate(
+                                            hpwh.NumofSpeed)));
                 ShowContinueError(state,
                                   " The MSHP system flow rate when waterheating is required is reset to the"
                                   " fan flow rate and the simulation continues.");
-                ShowContinueError(state, format(" Occurs in {}", state.dataWaterThermalTanks->HPWaterHeater(HPNum).Name));
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed) =
+                ShowContinueError(state, format(" Occurs in {}", hpwh.Name));
+                hpwh.HPWHAirVolFlowRate(hpwh.NumofSpeed) =
                     FanVolFlow;
                 // Check flow rates in other speeds and ensure flow rates are not above the max flow rate
-                for (int Iter = state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed - 1; Iter >= 1; --Iter) {
-                    if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(Iter) >
-                        state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(Iter + 1)) {
+                for (int Iter = hpwh.NumofSpeed - 1; Iter >= 1; --Iter) {
+                    if (hpwh.HPWHAirVolFlowRate(Iter) >
+                        hpwh.HPWHAirVolFlowRate(Iter + 1)) {
                         ShowContinueError(state,
                                           format(" The MSHP system flow rate when waterheating is required is reset to the flow rate at higher "
                                                  "speed and the simulation continues at Speed{}.",
                                                  Iter));
-                        ShowContinueError(state, format(" Occurs in {}", state.dataWaterThermalTanks->HPWaterHeater(HPNum).Name));
-                        state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(Iter) =
-                            state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(Iter + 1);
+                        ShowContinueError(state, format(" Occurs in {}", hpwh.Name));
+                        hpwh.HPWHAirVolFlowRate(Iter) =
+                            hpwh.HPWHAirVolFlowRate(Iter + 1);
                     }
                 }
             }
 
-            for (int Iter = 1; Iter <= state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed; ++Iter) {
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).MSAirSpeedRatio(Iter) =
-                    state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(Iter) /
-                    state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(
-                        state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed);
+            for (int Iter = 1; Iter <= hpwh.NumofSpeed; ++Iter) {
+                hpwh.MSAirSpeedRatio(Iter) = hpwh.HPWHAirVolFlowRate(Iter) / hpwh.HPWHAirVolFlowRate(hpwh.NumofSpeed);
             }
 
             // scale water flow rates
-            MulSpeedFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).RatedWaterVolFlowRate /
-                                state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).MSRatedWaterVolFlowRate(
-                                    state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).NormSpedLevel);
-            for (int Iter = 1; Iter <= state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed; ++Iter) {
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHWaterVolFlowRate(Iter) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).MSRatedWaterVolFlowRate(Iter) * MulSpeedFlowScale;
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHWaterMassFlowRate(Iter) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).MSRatedWaterMassFlowRate(Iter) * MulSpeedFlowScale;
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).MSWaterSpeedRatio(Iter) =
-                    state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).MSRatedWaterVolFlowRate(Iter) /
-                    state.dataVariableSpeedCoils->VarSpeedCoil(VSCoilID).MSRatedWaterVolFlowRate(
-                        state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed);
+            MulSpeedFlowScale = vsCoil.RatedWaterVolFlowRate / vsCoil.MSRatedWaterVolFlowRate(vsCoil.NormSpedLevel);
+            for (int Iter = 1; Iter <= hpwh.NumofSpeed; ++Iter) {
+                hpwh.HPWHWaterVolFlowRate(Iter) = vsCoil.MSRatedWaterVolFlowRate(Iter) * MulSpeedFlowScale;
+                hpwh.HPWHWaterMassFlowRate(Iter) = vsCoil.MSRatedWaterMassFlowRate(Iter) * MulSpeedFlowScale;
+                hpwh.MSWaterSpeedRatio(Iter) = vsCoil.MSRatedWaterVolFlowRate(Iter) / vsCoil.MSRatedWaterVolFlowRate(hpwh.NumofSpeed);
             }
 
             Real64 rhoAir = Psychrometrics::PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, HPInletDryBulbTemp, HPInletHumRat);
 
-            for (int Iter = 1; Iter <= state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed; ++Iter) {
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirMassFlowRate(Iter) =
-                    state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirVolFlowRate(Iter) * rhoAir;
+            for (int Iter = 1; Iter <= hpwh.NumofSpeed; ++Iter) {
+                hpwh.HPWHAirMassFlowRate(Iter) = hpwh.HPWHAirVolFlowRate(Iter) * rhoAir;
             }
 
             //   set the max mass flow rate for outdoor fans
-            state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanOutletNode).MassFlowRateMax =
-                state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHAirMassFlowRate(state.dataWaterThermalTanks->HPWaterHeater(HPNum).NumofSpeed);
+            state.dataLoopNodes->Node(hpwh.FanOutletNode).MassFlowRateMax =
+                hpwh.HPWHAirMassFlowRate(hpwh.NumofSpeed);
         }
 
     } //  IF(WaterThermalTank(WaterThermalTankNum)%HeatPumpNum .GT. 0)THEN
@@ -8358,8 +8288,10 @@ void WaterThermalTankData::CalcDesuperheaterWaterHeater(EnergyPlusData &state, b
     // simulate only the water heater tank if the lowest temperature available from the desuperheater coil
     // is less than water inlet temperature if the reclaim source is a refrigeration condenser
     if (DesupHtr.ValidSourceType) {
-        int SourceID = DesupHtr.ReclaimHeatingSourceIndexNum;
-        if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CondenserRefrigeration) {
+        int SourceID = DesupHtr.HeatReclaimSourceNum;
+        if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled ||
+            DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled ||
+            DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled) {
             if (state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).AvailTemperature <= this->SourceInletTemp) {
                 DesupHtr.Mode = TankOperatingMode::Floating;
                 this->CalcWaterThermalTank(state);
@@ -8418,7 +8350,9 @@ void WaterThermalTankData::CalcDesuperheaterWaterHeater(EnergyPlusData &state, b
     }
 
     // set limits on heat recovery efficiency
-    if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CondenserRefrigeration) {
+    if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled ||
+        DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled ||
+        DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled) {
         if ((HEffFTemp * Effic) > 0.9) HEffFTemp = 0.9 / Effic;
     } else { // max is 0.3 for all other sources
         if ((HEffFTemp * Effic) > 0.3) HEffFTemp = 0.3 / Effic;
@@ -8427,37 +8361,42 @@ void WaterThermalTankData::CalcDesuperheaterWaterHeater(EnergyPlusData &state, b
     // Access the appropriate structure to find the average heating capacity of the desuperheater heating coil
     Real64 AverageWasteHeat = 0.0;
     if (DesupHtr.ValidSourceType) {
-        int SourceID = DesupHtr.ReclaimHeatingSourceIndexNum;
-        if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CompressorRackRefrigeratedCase) {
+        if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCompressorRack) {
+            auto const &heatReclaim = state.dataHeatBal->HeatReclaimRefrigeratedRack(DesupHtr.HeatReclaimSourceNum);
             // Refrigeration systems are solved outside the time step iteration, so the
             //  appropriate decrement for other waste heat applications is handled differently
-            AverageWasteHeat = state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).AvailCapacity -
-                               state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).HVACDesuperheaterReclaimedHeatTotal;
+            AverageWasteHeat = heatReclaim.AvailCapacity - heatReclaim.HVACDesuperheaterReclaimedHeatTotal;
             DesupHtr.DXSysPLR = 1.0;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CondenserRefrigeration) {
-            AverageWasteHeat = state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).AvailCapacity -
-                               state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).HVACDesuperheaterReclaimedHeatTotal;
+
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled) {
+            auto const &heatReclaim = state.dataHeatBal->HeatReclaimRefrigCondenser(DesupHtr.HeatReclaimSourceNum);
+            AverageWasteHeat = heatReclaim.AvailCapacity - heatReclaim.HVACDesuperheaterReclaimedHeatTotal;
             DesupHtr.DXSysPLR = 1.0;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXCooling ||
-                   DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXMultiSpeed ||
-                   DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXMultiMode) {
-            AverageWasteHeat = state.dataHeatBal->HeatReclaimDXCoil(SourceID).AvailCapacity -
-                               state.dataHeatBal->HeatReclaimDXCoil(SourceID).HVACDesuperheaterReclaimedHeatTotal;
-            DesupHtr.DXSysPLR = state.dataDXCoils->DXCoil(SourceID).PartLoadRatio;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXVariableCooling ||
-                   DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::AirWaterHeatPumpVSEQ) {
-            AverageWasteHeat = state.dataHeatBal->HeatReclaimVS_Coil(SourceID).AvailCapacity -
-                               state.dataHeatBal->HeatReclaimVS_Coil(SourceID).HVACDesuperheaterReclaimedHeatTotal;
-            DesupHtr.DXSysPLR = state.dataVariableSpeedCoils->VarSpeedCoil(SourceID).PartLoadRatio;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::AirWaterHeatPumpEQ) {
-            AverageWasteHeat = state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).AvailCapacity -
-                               state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).HVACDesuperheaterReclaimedHeatTotal;
-            DesupHtr.DXSysPLR = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(SourceID).PartLoadRatio;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CoilCoolingDX) {
-            AverageWasteHeat =
-                state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.AvailCapacity -
-                state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.HVACDesuperheaterReclaimedHeatTotal;
-            DesupHtr.DXSysPLR = state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].partLoadRatioReport;
+
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXSingleSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiMode) {
+            auto const &heatReclaim = state.dataHeatBal->HeatReclaimDXCoil(DesupHtr.HeatReclaimSourceNum);
+            AverageWasteHeat = heatReclaim.AvailCapacity - heatReclaim.HVACDesuperheaterReclaimedHeatTotal;
+            DesupHtr.DXSysPLR = state.dataDXCoils->DXCoil(DesupHtr.HeatReclaimSourceNum).PartLoadRatio;
+
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXVariableSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolWAHPVariableSpeedEquationFit) {
+            auto const &heatReclaim = state.dataHeatBal->HeatReclaimVS_Coil(DesupHtr.HeatReclaimSourceNum);
+            AverageWasteHeat = heatReclaim.AvailCapacity - heatReclaim.HVACDesuperheaterReclaimedHeatTotal;
+            DesupHtr.DXSysPLR = state.dataVariableSpeedCoils->VarSpeedCoil(DesupHtr.HeatReclaimSourceNum).PartLoadRatio;
+
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolWAHPEquationFit) {
+            auto const &heatReclaim = state.dataHeatBal->HeatReclaimSimple_WAHPCoil(DesupHtr.HeatReclaimSourceNum);
+            AverageWasteHeat = heatReclaim.AvailCapacity - heatReclaim.HVACDesuperheaterReclaimedHeatTotal;
+            DesupHtr.DXSysPLR = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(DesupHtr.HeatReclaimSourceNum).PartLoadRatio;
+
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDX) {
+            auto const &heatReclaim = state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.HeatReclaimSourceNum];
+            AverageWasteHeat = heatReclaim.reclaimHeat.AvailCapacity - heatReclaim.reclaimHeat.HVACDesuperheaterReclaimedHeatTotal;
+            DesupHtr.DXSysPLR = heatReclaim.partLoadRatioReport;
         }
     } else {
         AverageWasteHeat = 0.0;
@@ -8768,44 +8707,52 @@ void WaterThermalTankData::CalcDesuperheaterWaterHeater(EnergyPlusData &state, b
 
     // Update used waste heat (just in case multiple users of waste heat use same source)
     if (DesupHtr.ValidSourceType) {
-        int SourceID = DesupHtr.ReclaimHeatingSourceIndexNum;
-        if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CompressorRackRefrigeratedCase) {
-            state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
-            state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
-            for (auto const &num : state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).WaterHeatingDesuperheaterReclaimedHeat)
-                state.dataHeatBal->HeatReclaimRefrigeratedRack(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal += num;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CondenserRefrigeration) {
-            state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
-            state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
-            for (auto const &num : state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).WaterHeatingDesuperheaterReclaimedHeat)
-                state.dataHeatBal->HeatReclaimRefrigCondenser(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal += num;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXCooling ||
-                   DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXMultiSpeed ||
-                   DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXMultiMode) {
-            state.dataHeatBal->HeatReclaimDXCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
-            state.dataHeatBal->HeatReclaimDXCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
-            for (auto const &num : state.dataHeatBal->HeatReclaimDXCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeat)
-                state.dataHeatBal->HeatReclaimDXCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal += num;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::DXVariableCooling ||
-                   DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::AirWaterHeatPumpVSEQ) {
-            state.dataHeatBal->HeatReclaimVS_Coil(SourceID).WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
-            state.dataHeatBal->HeatReclaimVS_Coil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
-            for (auto const &num : state.dataHeatBal->HeatReclaimVS_Coil(SourceID).WaterHeatingDesuperheaterReclaimedHeat)
-                state.dataHeatBal->HeatReclaimVS_Coil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal += num;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::AirWaterHeatPumpEQ) {
-            state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
-            state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
-            for (auto const &num : state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeat)
-                state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal += num;
-        } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CoilCoolingDX) {
-            state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat(
-                DesuperheaterNum) = DesupHtr.HeaterRate;
-            state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal =
-                0.0;
-            for (auto const &num :
-                 state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat)
-                state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum]
-                    .reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal += num;
+        if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCompressorRack) {
+            auto &heatReclaim = state.dataHeatBal->HeatReclaimRefrigeratedRack(DesupHtr.HeatReclaimSourceNum);
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
+            for (Real64 num : heatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal += num;
+
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserAirCooled ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserEvaporativeCooled ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::RefrigeratedCaseCondenserWaterCooled) {
+            auto &heatReclaim = state.dataHeatBal->HeatReclaimRefrigCondenser(DesupHtr.HeatReclaimSourceNum);
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
+            for (Real64 num : heatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal += num;
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXSingleSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXMultiMode) {
+            auto &heatReclaim = state.dataHeatBal->HeatReclaimDXCoil(DesupHtr.HeatReclaimSourceNum);
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
+            for (Real64 num : heatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal += num;
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDXVariableSpeed ||
+                   DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolWAHPVariableSpeedEquationFit) {
+            auto &heatReclaim = state.dataHeatBal->HeatReclaimVS_Coil(DesupHtr.HeatReclaimSourceNum);
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
+            for (Real64 num : heatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal += num;
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolWAHPEquationFit) {
+            auto &heatReclaim = state.dataHeatBal->HeatReclaimSimple_WAHPCoil(DesupHtr.HeatReclaimSourceNum);
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
+            heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
+            for (Real64 num : heatReclaim.WaterHeatingDesuperheaterReclaimedHeat)
+                heatReclaim.WaterHeatingDesuperheaterReclaimedHeatTotal += num;
+            
+        } else if (DesupHtr.HeatReclaimSourceType == HVAC::HeatReclaimType::CoilCoolDX) {
+            auto &heatReclaim = state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.HeatReclaimSourceNum];
+            heatReclaim.reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat(DesuperheaterNum) = DesupHtr.HeaterRate;
+            heatReclaim.reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0;
+            for (Real64 num : heatReclaim.reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat)
+                heatReclaim.reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal += num;
         }
     }
 }
@@ -8891,11 +8838,8 @@ void WaterThermalTankData::CalcHeatPumpWaterHeater(EnergyPlusData &state, bool c
         }
         //   pass node info and simulate crankcase heater
         if (MaxSpeedNum > 0) {
-            int VSCoilNum = HeatPump.DXCoilNum;
+            int VSCoilNum = (HeatPump.bIsIHP) ? state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).SCWHCoilNum : HeatPump.DXCoilNum;
 
-            if (HeatPump.bIsIHP) {
-                VSCoilNum = state.dataIntegratedHP->IntegratedHeatPumps(VSCoilNum).SCWHCoilIndex;
-            }
             // set the SCWH mode
             Real64 SpeedRatio = 1.0; // speed ratio for interpolating between two speed levels
             int SpeedNum = 1;
@@ -8903,71 +8847,41 @@ void WaterThermalTankData::CalcHeatPumpWaterHeater(EnergyPlusData &state, bool c
                 state.dataFans->fans(HeatPump.FanNum)->simulate(state, FirstHVACIteration, _, _);
 
                 this->SetVSHPWHFlowRates(state, HeatPump, SpeedNum, SpeedRatio, RhoWater, MdotWater, FirstHVACIteration);
-                if (HeatPump.bIsIHP)
-                    VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              "",
-                                                              VSCoilNum,
-                                                              HVAC::FanOp::Cycling,
-                                                              HVAC::CompressorOp::On,
-                                                              state.dataWaterThermalTanks->hpPartLoadRatio,
-                                                              SpeedNum,
-                                                              SpeedRatio,
-                                                              0.0,
-                                                              0.0,
-                                                              1.0);
-                else
-                    VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              HeatPump.DXCoilName,
-                                                              VSCoilNum,
-                                                              HVAC::FanOp::Cycling,
-                                                              HVAC::CompressorOp::On,
-                                                              state.dataWaterThermalTanks->hpPartLoadRatio,
-                                                              SpeedNum,
-                                                              SpeedRatio,
-                                                              0.0,
-                                                              0.0,
-                                                              1.0);
+                VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                                          VSCoilNum,
+                                                          HVAC::FanOp::Cycling,
+                                                          HVAC::CompressorOp::On,
+                                                          state.dataWaterThermalTanks->hpPartLoadRatio,
+                                                          SpeedNum,
+                                                          SpeedRatio,
+                                                          0.0,
+                                                          0.0,
+                                                          1.0);
             } else {
                 this->SetVSHPWHFlowRates(state, HeatPump, SpeedNum, SpeedRatio, RhoWater, MdotWater, FirstHVACIteration);
-                if (HeatPump.bIsIHP)
-                    VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              "",
-                                                              VSCoilNum,
-                                                              HVAC::FanOp::Cycling,
-                                                              HVAC::CompressorOp::On,
-                                                              state.dataWaterThermalTanks->hpPartLoadRatio,
-                                                              SpeedNum,
-                                                              SpeedRatio,
-                                                              0.0,
-                                                              0.0,
-                                                              1.0);
-                else
-                    VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                              HeatPump.DXCoilName,
-                                                              VSCoilNum,
-                                                              HVAC::FanOp::Cycling,
-                                                              HVAC::CompressorOp::On,
-                                                              state.dataWaterThermalTanks->hpPartLoadRatio,
-                                                              SpeedNum,
-                                                              SpeedRatio,
-                                                              0.0,
-                                                              0.0,
-                                                              1.0);
+                VariableSpeedCoils::SimVariableSpeedCoils(state,
+                                                          VSCoilNum,
+                                                          HVAC::FanOp::Cycling,
+                                                          HVAC::CompressorOp::On,
+                                                          state.dataWaterThermalTanks->hpPartLoadRatio,
+                                                          SpeedNum,
+                                                          SpeedRatio,
+                                                          0.0,
+                                                          0.0,
+                                                          1.0);
                 state.dataFans->fans(HeatPump.FanNum)->simulate(state, FirstHVACIteration, _, _);
             }
 
             // set the DWH mode
             if (HeatPump.bIsIHP) {
-                VSCoilNum = state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).DWHCoilIndex;
+                VSCoilNum =  state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).DWHCoilNum;
 
-                if (VSCoilNum > 0) // if DWH coil exists
-                {
+                if (VSCoilNum > 0) { // if DWH coil exists
                     if (HeatPump.fanPlace == HVAC::FanPlace::BlowThru) {
                         state.dataFans->fans(HeatPump.FanNum)->simulate(state, FirstHVACIteration, _, _);
 
                         this->SetVSHPWHFlowRates(state, HeatPump, SpeedNum, SpeedRatio, RhoWater, MdotWater, FirstHVACIteration);
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                  "",
                                                                   VSCoilNum,
                                                                   HVAC::FanOp::Cycling,
                                                                   HVAC::CompressorOp::On,
@@ -8980,7 +8894,6 @@ void WaterThermalTankData::CalcHeatPumpWaterHeater(EnergyPlusData &state, bool c
                     } else {
                         this->SetVSHPWHFlowRates(state, HeatPump, SpeedNum, SpeedRatio, RhoWater, MdotWater, FirstHVACIteration);
                         VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                                  "",
                                                                   VSCoilNum,
                                                                   HVAC::FanOp::Cycling,
                                                                   HVAC::CompressorOp::On,
@@ -9000,18 +8913,16 @@ void WaterThermalTankData::CalcHeatPumpWaterHeater(EnergyPlusData &state, bool c
                 state.dataFans->fans(HeatPump.FanNum)->simulate(state, FirstHVACIteration, _, _);
 
                 DXCoils::SimDXCoil(state,
-                                   HeatPump.DXCoilName,
+                                   HeatPump.DXCoilNum,
                                    compressorOp,
                                    FirstHVACIteration,
-                                   HeatPump.DXCoilNum,
                                    HVAC::FanOp::Cycling,
                                    state.dataWaterThermalTanks->hpPartLoadRatio);
             } else {
                 DXCoils::SimDXCoil(state,
-                                   HeatPump.DXCoilName,
+                                   HeatPump.DXCoilNum,
                                    compressorOp,
                                    FirstHVACIteration,
-                                   HeatPump.DXCoilNum,
                                    HVAC::FanOp::Cycling,
                                    state.dataWaterThermalTanks->hpPartLoadRatio);
                 state.dataFans->fans(HeatPump.FanNum)->simulate(state, FirstHVACIteration, _, _);
@@ -9252,11 +9163,11 @@ void WaterThermalTankData::CalcHeatPumpWaterHeater(EnergyPlusData &state, bool c
                 if (state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).CheckWHCall) {
                     int VSCoilNum;
                     if (IntegratedHeatPump::IHPOperationMode::DedicatedWaterHtg == IHPMode) {
-                        VSCoilNum = state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).DWHCoilIndex;
+                        VSCoilNum = state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).DWHCoilNum;
                         state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).CurMode =
                             IntegratedHeatPump::IHPOperationMode::DedicatedWaterHtg;
                     } else {
-                        VSCoilNum = state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).SCWHCoilIndex;
+                        VSCoilNum = state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).SCWHCoilNum;
                         state.dataIntegratedHP->IntegratedHeatPumps(HeatPump.DXCoilNum).CurMode = IntegratedHeatPump::IHPOperationMode::SCWHMatchWH;
                     }
 
@@ -10084,14 +9995,13 @@ Real64 WaterThermalTankData::PLRResidualIterSpeed(EnergyPlusData &state,
     state.dataWaterThermalTanks->hpPartLoadRatio = 1.0;
     Real64 MdotWater = 0.0;
 
-    auto &HPWH = state.dataWaterThermalTanks->HPWaterHeater(HPNum);
+    auto &hpwh = state.dataWaterThermalTanks->HPWaterHeater(HPNum);
 
-    this->SetVSHPWHFlowRates(state, HPWH, SpeedNum, SpeedRatio, RhoWater, MdotWater, FirstHVACIteration);
+    this->SetVSHPWHFlowRates(state, hpwh, SpeedNum, SpeedRatio, RhoWater, MdotWater, FirstHVACIteration);
 
-    if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).bIsIHP) {
+    if (hpwh.bIsIHP) {
         IntegratedHeatPump::SimIHP(state,
-                                   state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
-                                   state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
+                                   hpwh.DXCoilNum,
                                    HVAC::FanOp::Cycling,
                                    HVAC::CompressorOp::On,
                                    state.dataWaterThermalTanks->hpPartLoadRatio,
@@ -10104,8 +10014,7 @@ Real64 WaterThermalTankData::PLRResidualIterSpeed(EnergyPlusData &state,
                                    1.0);
     } else {
         VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                  state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
-                                                  state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
+                                                  hpwh.DXCoilNum,
                                                   HVAC::FanOp::Cycling,
                                                   HVAC::CompressorOp::On,
                                                   state.dataWaterThermalTanks->hpPartLoadRatio,
@@ -10126,10 +10035,10 @@ Real64 WaterThermalTankData::PLRResidualIterSpeed(EnergyPlusData &state,
     //           this CALL does not update node temps, must use WaterThermalTank variables
     // select tank type
     Real64 NewTankTemp = 0.0;
-    if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHTankType == DataPlant::PlantEquipmentType::WtrHeaterMixed) {
+    if (hpwh.HPWHTankType == DataPlant::PlantEquipmentType::WtrHeaterMixed) {
         this->CalcWaterThermalTankMixed(state);
         NewTankTemp = this->TankTemp;
-    } else if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHTankType == DataPlant::PlantEquipmentType::WtrHeaterStratified) {
+    } else if (hpwh.HPWHTankType == DataPlant::PlantEquipmentType::WtrHeaterStratified) {
         this->CalcWaterThermalTankStratified(state);
         NewTankTemp = this->FindStratifiedTankSensedTemp(state);
     }
@@ -11798,19 +11707,20 @@ void WaterThermalTankData::CalcStandardRatings(EnergyPlusData &state)
 
             } else {
 
-                int HPNum = this->HeatPumpNum;  // Convenience variable
+                auto &hpwh = state.dataWaterThermalTanks->HPWaterHeater(this->HeatPumpNum);
+
                 Real64 AmbientHumRat = 0.00717; // Humidity ratio at 67.5 F / 50% RH
 
                 //       set the heat pump air- and water-side mass flow rate
-                Real64 MdotWater = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingWaterFlowRate * Psychrometrics::RhoH2O(this->TankTemp);
-                Real64 mdotAir = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OperatingAirMassFlowRate;
+                Real64 MdotWater = hpwh.OperatingWaterFlowRate * Psychrometrics::RhoH2O(this->TankTemp);
+                Real64 mdotAir = hpwh.OperatingAirMassFlowRate;
 
                 // ?? why is HPWH condenser inlet node temp reset inside the for loop? shouldn't it chnage with the tank temp throughout these
                 // iterations?
-                if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped) {
+                if (hpwh.HPWHType == DataPlant::PlantEquipmentType::HeatPumpWtrHeaterPumped) {
                     // set the condenser inlet node mass flow rate and temperature
-                    state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).CondWaterInletNode).MassFlowRate = MdotWater;
-                    state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).CondWaterInletNode).Temp = this->TankTemp;
+                    state.dataLoopNodes->Node(hpwh.CondWaterInletNode).MassFlowRate = MdotWater;
+                    state.dataLoopNodes->Node(hpwh.CondWaterInletNode).Temp = this->TankTemp;
                 }
 
                 //       initialize temperatures for HPWH DX Coil heating capacity and COP curves
@@ -11819,85 +11729,76 @@ void WaterThermalTankData::CalcStandardRatings(EnergyPlusData &state)
                     Psychrometrics::PsyTwbFnTdbWPb(state, state.dataHVACGlobal->HPWHInletDBTemp, AmbientHumRat, state.dataEnvrn->OutBaroPress);
 
                 //       set up full air flow on DX coil inlet node
-                if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirMixerNode > 0) {
-                    state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirMixerNode).MassFlowRate = mdotAir;
-                    state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirMixerNode).MassFlowRateMaxAvail = mdotAir;
-                    state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirMixerNode).Temp = this->AmbientTemp;
-                    state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirMixerNode).HumRat = AmbientHumRat;
-                    state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).InletAirMixerNode).Enthalpy =
+                if (hpwh.InletAirMixerNode > 0) {
+                    state.dataLoopNodes->Node(hpwh.InletAirMixerNode).MassFlowRate = mdotAir;
+                    state.dataLoopNodes->Node(hpwh.InletAirMixerNode).MassFlowRateMaxAvail = mdotAir;
+                    state.dataLoopNodes->Node(hpwh.InletAirMixerNode).Temp = this->AmbientTemp;
+                    state.dataLoopNodes->Node(hpwh.InletAirMixerNode).HumRat = AmbientHumRat;
+                    state.dataLoopNodes->Node(hpwh.InletAirMixerNode).Enthalpy =
                         Psychrometrics::PsyHFnTdbW(this->AmbientTemp, AmbientHumRat);
                 } else {
-                    if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutsideAirNode == 0) {
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatPumpAirInletNode).MassFlowRate = mdotAir;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatPumpAirInletNode).MassFlowRateMaxAvail =
-                            mdotAir;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatPumpAirInletNode).Temp = this->AmbientTemp;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatPumpAirInletNode).HumRat = AmbientHumRat;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).HeatPumpAirInletNode).Enthalpy =
+                    if (hpwh.OutsideAirNode == 0) {
+                        state.dataLoopNodes->Node(hpwh.HeatPumpAirInletNode).MassFlowRate = mdotAir;
+                        state.dataLoopNodes->Node(hpwh.HeatPumpAirInletNode).MassFlowRateMaxAvail = mdotAir;
+                        state.dataLoopNodes->Node(hpwh.HeatPumpAirInletNode).Temp = this->AmbientTemp;
+                        state.dataLoopNodes->Node(hpwh.HeatPumpAirInletNode).HumRat = AmbientHumRat;
+                        state.dataLoopNodes->Node(hpwh.HeatPumpAirInletNode).Enthalpy =
                             Psychrometrics::PsyHFnTdbW(this->AmbientTemp, AmbientHumRat);
                     } else {
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutsideAirNode).MassFlowRate = mdotAir;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutsideAirNode).MassFlowRateMaxAvail = mdotAir;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutsideAirNode).Temp = this->AmbientTemp;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutsideAirNode).HumRat = AmbientHumRat;
-                        state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).OutsideAirNode).Enthalpy =
+                        state.dataLoopNodes->Node(hpwh.OutsideAirNode).MassFlowRate = mdotAir;
+                        state.dataLoopNodes->Node(hpwh.OutsideAirNode).MassFlowRateMaxAvail = mdotAir;
+                        state.dataLoopNodes->Node(hpwh.OutsideAirNode).Temp = this->AmbientTemp;
+                        state.dataLoopNodes->Node(hpwh.OutsideAirNode).HumRat = AmbientHumRat;
+                        state.dataLoopNodes->Node(hpwh.OutsideAirNode).Enthalpy =
                             Psychrometrics::PsyHFnTdbW(this->AmbientTemp, AmbientHumRat);
                     }
                 }
 
                 state.dataHVACGlobal->HPWHCrankcaseDBTemp = this->AmbientTemp;
 
-                if (Util::SameString(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilType,
-                                     "Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed") ||
-                    (state.dataWaterThermalTanks->HPWaterHeater(HPNum).bIsIHP)) {
+                if (hpwh.DXCoilType == HVAC::CoilType::WaterHeatingAWHPVariableSpeed ||
+                    hpwh.bIsIHP) {
                     bIsVSCoil = true;
-                    std::string VSCoilName = state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName;
-                    int VSCoilNum = state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum;
-                    if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).bIsIHP) {
-                        VSCoilNum =
-                            state.dataIntegratedHP->IntegratedHeatPumps(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).SCWHCoilIndex;
-                        VSCoilName =
-                            state.dataIntegratedHP->IntegratedHeatPumps(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).SCWHCoilName;
+                    int VSCoilNum = hpwh.DXCoilNum;
+                    if (hpwh.bIsIHP) {
+                        VSCoilNum = state.dataIntegratedHP->IntegratedHeatPumps(hpwh.DXCoilNum).SCWHCoilNum;
                     }
 
                     Real64 RhoWater = Psychrometrics::RhoH2O(this->TankTemp);
-                    auto &HPWH = state.dataWaterThermalTanks->HPWaterHeater(HPNum);
                     this->SetVSHPWHFlowRates(
                         state,
-                        HPWH,
-                        state.dataVariableSpeedCoils->VarSpeedCoil(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).NormSpedLevel,
+                        hpwh,
+                        state.dataVariableSpeedCoils->VarSpeedCoil(hpwh.DXCoilNum).NormSpedLevel,
                         1.0,
                         RhoWater,
                         MdotWater,
                         true);
                     //       simulate the HPWH coil/fan to find heating capacity
-                    if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).fanPlace == HVAC::FanPlace::BlowThru) {
+                    if (hpwh.fanPlace == HVAC::FanPlace::BlowThru) {
                         //   simulate fan and DX coil twice
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
 
                         VariableSpeedCoils::SimVariableSpeedCoils(
                             state,
-                            VSCoilName,
                             VSCoilNum,
                             HVAC::FanOp::Cycling,
                             HVAC::CompressorOp::On,
                             1.0,
-                            state.dataVariableSpeedCoils->VarSpeedCoil(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).NormSpedLevel,
+                            state.dataVariableSpeedCoils->VarSpeedCoil(hpwh.DXCoilNum).NormSpedLevel,
                             1.0,
                             0.0,
                             0.0,
                             1.0);
 
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
 
                         VariableSpeedCoils::SimVariableSpeedCoils(
                             state,
-                            VSCoilName,
                             VSCoilNum,
                             HVAC::FanOp::Cycling,
                             HVAC::CompressorOp::On,
                             1.0,
-                            state.dataVariableSpeedCoils->VarSpeedCoil(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).NormSpedLevel,
+                            state.dataVariableSpeedCoils->VarSpeedCoil(hpwh.DXCoilNum).NormSpedLevel,
                             1.0,
                             0.0,
                             0.0,
@@ -11906,33 +11807,31 @@ void WaterThermalTankData::CalcStandardRatings(EnergyPlusData &state)
                         //   simulate DX coil and fan twice to pass fan power (FanElecPower) to DX coil
                         VariableSpeedCoils::SimVariableSpeedCoils(
                             state,
-                            VSCoilName,
                             VSCoilNum,
                             HVAC::FanOp::Cycling,
                             HVAC::CompressorOp::On,
                             1.0,
-                            state.dataVariableSpeedCoils->VarSpeedCoil(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).NormSpedLevel,
+                            state.dataVariableSpeedCoils->VarSpeedCoil(hpwh.DXCoilNum).NormSpedLevel,
                             1.0,
                             0.0,
                             0.0,
                             1.0);
 
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
 
                         VariableSpeedCoils::SimVariableSpeedCoils(
                             state,
-                            VSCoilName,
                             VSCoilNum,
                             HVAC::FanOp::Cycling,
                             HVAC::CompressorOp::On,
                             1.0,
-                            state.dataVariableSpeedCoils->VarSpeedCoil(state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum).NormSpedLevel,
+                            state.dataVariableSpeedCoils->VarSpeedCoil(hpwh.DXCoilNum).NormSpedLevel,
                             1.0,
                             0.0,
                             0.0,
                             1.0);
 
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
                     }
 
                     this->MaxCapacity = state.dataVariableSpeedCoils->VSHPWHHeatingCapacity;
@@ -11941,74 +11840,68 @@ void WaterThermalTankData::CalcStandardRatings(EnergyPlusData &state)
                 } else {
                     bIsVSCoil = false;
                     //       simulate the HPWH coil/fan to find heating capacity
-                    if (state.dataWaterThermalTanks->HPWaterHeater(HPNum).fanPlace == HVAC::FanPlace::BlowThru) {
+                    if (hpwh.fanPlace == HVAC::FanPlace::BlowThru) {
                         if (FirstTimeFlag) { // first time DXCoils::DXCoil is called, it's sized at the RatedCondenserWaterInlet temp, size and
                                              // reset water inlet temp. If already sized, no harm.
-                            state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                            state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
 
                             DXCoils::SimDXCoil(state,
-                                               state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
+                                               hpwh.DXCoilNum,
                                                HVAC::CompressorOp::On,
                                                true,
-                                               state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
                                                HVAC::FanOp::Cycling,
                                                1.0);
-                            state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).CondWaterInletNode).Temp = this->TankTemp;
+                            state.dataLoopNodes->Node(hpwh.CondWaterInletNode).Temp = this->TankTemp;
                         }
                         // ?? should only need to call twice if PLR<1 since this might affect OnOffFanPartLoadFraction which impacts fan energy.
                         // PLR=1 here.
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
 
                         DXCoils::SimDXCoil(state,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
+                                           hpwh.DXCoilNum,
                                            HVAC::CompressorOp::On,
                                            true,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
                                            HVAC::FanOp::Cycling,
                                            1.0);
 
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
 
                         DXCoils::SimDXCoil(state,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
+                                           hpwh.DXCoilNum,
                                            HVAC::CompressorOp::On,
                                            true,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
                                            HVAC::FanOp::Cycling,
                                            1.0);
                     } else {
                         if (FirstTimeFlag) { // first time DXCoils::DXCoil is called, it's sized at the RatedCondenserWaterInlet temp, size and
                                              // reset water inlet temp. If already sized, no harm.
                             DXCoils::SimDXCoil(state,
-                                               state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
+                                               hpwh.DXCoilNum,
                                                HVAC::CompressorOp::On,
                                                true,
-                                               state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
                                                HVAC::FanOp::Cycling,
                                                1.0);
-                            state.dataLoopNodes->Node(state.dataWaterThermalTanks->HPWaterHeater(HPNum).CondWaterInletNode).Temp = this->TankTemp;
+                            state.dataLoopNodes->Node(hpwh.CondWaterInletNode).Temp = this->TankTemp;
                         }
                         // ?? should only need to call twice if PLR<1 since this might affect OnOffFanPartLoadFraction which impacts fan energy.
                         // PLR=1 here.
                         DXCoils::SimDXCoil(state,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
+                                           hpwh.DXCoilNum,
                                            HVAC::CompressorOp::On,
                                            true,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
                                            HVAC::FanOp::Cycling,
                                            1.0);
 
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
 
                         DXCoils::SimDXCoil(state,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilName,
+                                           hpwh.DXCoilNum,
                                            HVAC::CompressorOp::On,
                                            true,
-                                           state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilNum,
                                            HVAC::FanOp::Cycling,
                                            1.0);
 
-                        state.dataFans->fans(state.dataWaterThermalTanks->HPWaterHeater(HPNum).FanNum)->simulate(state, true, _, _);
+                        state.dataFans->fans(hpwh.FanNum)->simulate(state, true, _, _);
                     }
 
                     this->MaxCapacity = state.dataDXCoils->HPWHHeatingCapacity;
@@ -12024,11 +11917,11 @@ void WaterThermalTankData::CalcStandardRatings(EnergyPlusData &state)
                 //       Switch the HPWH info with the tank info and call CalcWaterThermalTankMixed to get Standard Rating
                 //       (backup element is assumed to be disabled during the rating procedure)
                 this->SourceMassFlowRate = 0.0;
-                this->OnCycParaLoad = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OnCycParaLoad;
-                this->OffCycParaLoad = state.dataWaterThermalTanks->HPWaterHeater(HPNum).OffCycParaLoad;
+                this->OnCycParaLoad = hpwh.OnCycParaLoad;
+                this->OffCycParaLoad = hpwh.OffCycParaLoad;
                 this->OffCycParaFracToTank = 0.0;
                 this->OnCycParaFracToTank = 0.0;
-                this->PLFCurve = state.dataWaterThermalTanks->HPWaterHeater(HPNum).DXCoilPLFFPLR;
+                this->PLFCurve = hpwh.DXCoilPLFFPLR;
 
                 if (this->WaterThermalTankType == DataPlant::PlantEquipmentType::WtrHeaterMixed) {
                     if (this->Efficiency > 0.0) this->CalcWaterThermalTankMixed(state);
@@ -12038,14 +11931,14 @@ void WaterThermalTankData::CalcStandardRatings(EnergyPlusData &state)
                 }
 
                 //       reset the water heater data to original values
-                this->MaxCapacity = state.dataWaterThermalTanks->HPWaterHeater(HPNum).BackupElementCapacity;
-                this->MinCapacity = state.dataWaterThermalTanks->HPWaterHeater(HPNum).BackupElementCapacity;
-                this->Efficiency = state.dataWaterThermalTanks->HPWaterHeater(HPNum).BackupElementEfficiency;
-                this->OnCycParaLoad = state.dataWaterThermalTanks->HPWaterHeater(HPNum).WHOnCycParaLoad;
-                this->OffCycParaLoad = state.dataWaterThermalTanks->HPWaterHeater(HPNum).WHOffCycParaLoad;
-                this->OnCycParaFracToTank = state.dataWaterThermalTanks->HPWaterHeater(HPNum).WHOnCycParaFracToTank;
-                this->OffCycParaFracToTank = state.dataWaterThermalTanks->HPWaterHeater(HPNum).WHOffCycParaFracToTank;
-                this->PLFCurve = state.dataWaterThermalTanks->HPWaterHeater(HPNum).WHPLFCurve;
+                this->MaxCapacity = hpwh.BackupElementCapacity;
+                this->MinCapacity = hpwh.BackupElementCapacity;
+                this->Efficiency = hpwh.BackupElementEfficiency;
+                this->OnCycParaLoad = hpwh.WHOnCycParaLoad;
+                this->OffCycParaLoad = hpwh.WHOffCycParaLoad;
+                this->OnCycParaFracToTank = hpwh.WHOnCycParaFracToTank;
+                this->OffCycParaFracToTank = hpwh.WHOffCycParaFracToTank;
+                this->PLFCurve = hpwh.WHPLFCurve;
             }
 
             FuelEnergy_loc += (this->FuelRate + this->OffCycParaFuelRate + this->OnCycParaFuelRate) * SecInTimeStep;
diff --git a/src/EnergyPlus/WaterThermalTanks.hh b/src/EnergyPlus/WaterThermalTanks.hh
index cfe31fd6049..f1282b2eafc 100644
--- a/src/EnergyPlus/WaterThermalTanks.hh
+++ b/src/EnergyPlus/WaterThermalTanks.hh
@@ -148,22 +148,6 @@ namespace WaterThermalTanks {
 
     constexpr std::array<std::string_view, static_cast<int>(InletPositionMode::Num)> InletPositionModeNamesUC{"FIXED", "SEEKING"};
 
-    // reclaim heat object types for Coil:WaterHeating:Desuperheater object
-    enum class ReclaimHeatObjectType
-    {
-        Invalid = -1,
-        CoilCoolingDX,                  // reclaim heating source is new DX Cooling coil
-        CompressorRackRefrigeratedCase, // reclaim heating source is refrigerated case compressor rack
-        DXCooling,                      // reclaim heating source is DX cooling coil
-        DXMultiSpeed,                   // reclaim heating source is DX multispeed coil
-        DXMultiMode,                    // reclaim heating source is DX multimode coil
-        CondenserRefrigeration,         // reclaim heating source is detailed refrigeration system condenser
-        DXVariableCooling,              // reclaim heating source is Variable Speed DX cooling coil
-        AirWaterHeatPumpEQ,             // reclaim heating source is Water to air heat pump cooling coil
-        AirWaterHeatPumpVSEQ,           // reclaim heating source is Water to air heat pump variable speed cooling coil
-        Num
-    };
-
     enum class WaterHeaterSide
     {
         Invalid = -1,
@@ -329,10 +313,9 @@ namespace WaterThermalTanks {
         int WHUseInletNode;                                         // Water heater tank use side inlet node
         int WHUseOutletNode;                                        // Water heater tank use side outlet node
         int WHUseSidePlantLoopNum;                                  // if not zero, then this water heater is on plant loop #
-        std::string DXCoilType;                                     // Type of DX coil (Coil:DX:HeatPumpWaterHeater)
+        HVAC::CoilType DXCoilType = HVAC::CoilType::Invalid;        // Type of DX coil (Coil:DX:HeatPumpWaterHeater)
         std::string DXCoilName;                                     // Name of DX coil
         int DXCoilNum;                                              // Index of DX coil
-        int DXCoilTypeNum;                                          // Type Number of DX coil
         int DXCoilAirInletNode;                                     // Inlet air node number of DX coil
         int DXCoilPLFFPLR;                                          // Index to HPWH's DX Coil PLF as a function of PLR curve
         HVAC::FanType fanType;                                      // Integer type of fan (3 = Fan:OnOff)
@@ -432,7 +415,7 @@ namespace WaterThermalTanks {
               OperatingAirMassFlowRate(0.0), OperatingWaterFlowRate(0.0), COP(0.0), SHR(0.0), RatedInletDBTemp(0.0), RatedInletWBTemp(0.0),
               RatedInletWaterTemp(0.0), FoundTank(false), HeatPumpAirInletNode(0), HeatPumpAirOutletNode(0), OutsideAirNode(0), ExhaustAirNode(0),
               CondWaterInletNode(0), CondWaterOutletNode(0), WHUseInletNode(0), WHUseOutletNode(0), WHUseSidePlantLoopNum(0), DXCoilNum(0),
-              DXCoilTypeNum(0), DXCoilAirInletNode(0), DXCoilPLFFPLR(0), fanType(HVAC::FanType::Invalid), FanNum(0),
+              DXCoilAirInletNode(0), DXCoilPLFFPLR(0), fanType(HVAC::FanType::Invalid), FanNum(0),
               fanPlace(HVAC::FanPlace::Invalid), FanOutletNode(0), WaterHeaterTankNum(0), Power(0.0), Energy(0.0), HeatingPLR(0.0), SetPointTemp(0.0),
               MinAirTempForHPOperation(5.0), MaxAirTempForHPOperation(48.8888888889), InletAirMixerNode(0), OutletAirSplitterNode(0),
               SourceMassFlowRate(0.0), InletAirConfiguration(WTTAmbientTemp::OutsideAir), AmbientTempZone(0),
@@ -899,8 +882,6 @@ namespace WaterThermalTanks {
         std::string TankName;                      // Name of tank associated with desuperheater
         int TankNum;
         bool StandAlone;                                            // Flag for operation with no plant connections (no use nodes)
-        std::string HeatingSourceType;                              // Type of heating source (DX coil or refrigerated rack)
-        std::string HeatingSourceName;                              // Name of heating source
         Real64 HeaterRate;                                          // Report variable for desuperheater heating rate [W]
         Real64 HeaterEnergy;                                        // Report variable for desuperheater heating energy [J]
         Real64 PumpPower;                                           // Report variable for water circulation pump power [W]
@@ -924,8 +905,11 @@ namespace WaterThermalTanks {
         TankOperatingMode SaveWHMode = TankOperatingMode::Floating; // mode of water heater tank element (backup element)
         Real64 BackupElementCapacity;                               // Tank backup element capacity (W)
         Real64 DXSysPLR;                                            // runtime fraction of desuperheater heating coil
-        int ReclaimHeatingSourceIndexNum;                           // Index to reclaim heating source (condenser) of a specific type
-        ReclaimHeatObjectType ReclaimHeatingSource;                 // The source for the Desuperheater Heating Coil
+
+        std::string HeatReclaimSourceName;                              // Name of heating source
+        int HeatReclaimSourceNum = 0;                           // Index to reclaim heating source (condenser) of a specific type
+        HVAC::HeatReclaimType HeatReclaimSourceType = HVAC::HeatReclaimType::Invalid;               // The source for the Desuperheater Heating Coil
+
         int SetPointError;                                          // Used when temp SP in tank and desuperheater are reversed
         int SetPointErrIndex1;                                      // Index to recurring error for tank/desuperheater set point temp
         int IterLimitErrIndex1;                                     // Index for recurring iteration limit warning messages
@@ -951,8 +935,8 @@ namespace WaterThermalTanks {
               TankNum(0), StandAlone(false), HeaterRate(0.0), HeaterEnergy(0.0), PumpPower(0.0), PumpEnergy(0.0), PumpElecPower(0.0),
               PumpFracToWater(0.0), OperatingWaterFlowRate(0.0), HEffFTemp(0), HEffFTempOutput(0.0), SetPointTemp(0.0), WaterHeaterTankNum(0),
               DesuperheaterPLR(0.0), OnCycParaLoad(0.0), OffCycParaLoad(0.0), OnCycParaFuelEnergy(0.0), OnCycParaFuelRate(0.0),
-              OffCycParaFuelEnergy(0.0), OffCycParaFuelRate(0.0), BackupElementCapacity(0.0), DXSysPLR(0.0), ReclaimHeatingSourceIndexNum(0),
-              ReclaimHeatingSource(ReclaimHeatObjectType::DXCooling), SetPointError(0), SetPointErrIndex1(0), IterLimitErrIndex1(0),
+              OffCycParaFuelEnergy(0.0), OffCycParaFuelRate(0.0), BackupElementCapacity(0.0), DXSysPLR(0.0), 
+              SetPointError(0), SetPointErrIndex1(0), IterLimitErrIndex1(0),
               IterLimitExceededNum1(0), RegulaFalsiFailedIndex1(0), RegulaFalsiFailedNum1(0), IterLimitErrIndex2(0), IterLimitExceededNum2(0),
               RegulaFalsiFailedIndex2(0), RegulaFalsiFailedNum2(0), FirstTimeThroughFlag(true), ValidSourceType(false)
         {
diff --git a/src/EnergyPlus/WaterToAirHeatPump.cc b/src/EnergyPlus/WaterToAirHeatPump.cc
index 9817730e518..71bee003f9c 100644
--- a/src/EnergyPlus/WaterToAirHeatPump.cc
+++ b/src/EnergyPlus/WaterToAirHeatPump.cc
@@ -154,20 +154,39 @@ namespace WaterToAirHeatPump {
         }
         // Calculate the Correct Water to Air HP Model with the current HPNum
 
-        if (state.dataWaterToAirHeatPump->WatertoAirHP(HPNum).WAHPType == DataPlant::PlantEquipmentType::CoilWAHPCoolingParamEst) {
-            InitWatertoAirHP(state, HPNum, InitFlag, SensLoad, LatentLoad, DesignAirflow, PartLoadRatio);
-            CalcWatertoAirHPCooling(state, HPNum, fanOp, FirstHVACIteration, InitFlag, SensLoad, compressorOp, PartLoadRatio);
-
-            UpdateWatertoAirHP(state, HPNum);
-
-        } else if (state.dataWaterToAirHeatPump->WatertoAirHP(HPNum).WAHPType == DataPlant::PlantEquipmentType::CoilWAHPHeatingParamEst) {
-            InitWatertoAirHP(state, HPNum, InitFlag, SensLoad, LatentLoad, DesignAirflow, PartLoadRatio);
-            CalcWatertoAirHPHeating(state, HPNum, fanOp, FirstHVACIteration, InitFlag, SensLoad, compressorOp, PartLoadRatio);
-
-            UpdateWatertoAirHP(state, HPNum);
-
-        } else {
-            ShowFatalError(state, "SimWatertoAirHP: AirtoAir heatpump not in either HEATING or COOLING");
+        SimWatertoAirHP(state,
+                        HPNum,
+                        DesignAirflow,    // design air flow rate
+                        fanOp,       // cycling scheme--either continuous fan/cycling compressor or
+                        FirstHVACIteration, // first iteration flag
+                        InitFlag,           // initialization flag used to suppress property routine errors
+                        SensLoad,         // sensible load
+                        LatentLoad,       // latent load
+                        compressorOp,
+                        PartLoadRatio);
+    }
+  
+    void SimWatertoAirHP(EnergyPlusData &state,
+                         int const hpNum,
+                         Real64 const DesignAirflow,    // design air flow rate
+                         HVAC::FanOp const fanOp,       // cycling scheme--either continuous fan/cycling compressor or
+                         bool const FirstHVACIteration, // first iteration flag
+                         bool const InitFlag,           // initialization flag used to suppress property routine errors
+                         Real64 const SensLoad,         // sensible load
+                         Real64 const LatentLoad,       // latent load
+                         HVAC::CompressorOp const compressorOp,
+                         Real64 const PartLoadRatio)
+    {
+      assert(hpNum > 0 && hpNum <= state.dataWaterToAirHeatPump->NumWatertoAirHPs);
+      if (state.dataWaterToAirHeatPump->WatertoAirHP(hpNum).coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingParamEst) {
+            InitWatertoAirHP(state, hpNum, InitFlag, SensLoad, LatentLoad, DesignAirflow, PartLoadRatio);
+            CalcWatertoAirHPCooling(state, hpNum, fanOp, FirstHVACIteration, InitFlag, SensLoad, compressorOp, PartLoadRatio);
+            UpdateWatertoAirHP(state, hpNum);
+
+        } else if (state.dataWaterToAirHeatPump->WatertoAirHP(hpNum).coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingParamEst) {
+            InitWatertoAirHP(state, hpNum, InitFlag, SensLoad, LatentLoad, DesignAirflow, PartLoadRatio);
+            CalcWatertoAirHPHeating(state, hpNum, fanOp, FirstHVACIteration, InitFlag, SensLoad, compressorOp, PartLoadRatio);
+            UpdateWatertoAirHP(state, hpNum);
         }
     }
 
@@ -272,8 +291,7 @@ namespace WaterToAirHeatPump {
             auto &heatPump = state.dataWaterToAirHeatPump->WatertoAirHP(HPNum);
 
             heatPump.Name = AlphArray(1);
-            heatPump.WatertoAirHPType = "COOLING";
-            heatPump.WAHPType = DataPlant::PlantEquipmentType::CoilWAHPCoolingParamEst;
+            heatPump.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingParamEst;
             heatPump.Refrigerant = AlphArray(3);
             if (heatPump.Refrigerant.empty()) {
                 ShowSevereEmptyField(state, eoh, cAlphaFields(3));
@@ -528,8 +546,7 @@ namespace WaterToAirHeatPump {
             auto &heatPump = state.dataWaterToAirHeatPump->WatertoAirHP(HPNum);
 
             heatPump.Name = AlphArray(1);
-            heatPump.WatertoAirHPType = "HEATING";
-            heatPump.WAHPType = DataPlant::PlantEquipmentType::CoilWAHPHeatingParamEst;
+            heatPump.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingParamEst;
             heatPump.Refrigerant = AlphArray(3);
             if (heatPump.Refrigerant.empty()) {
                 ShowSevereEmptyField(state, eoh, cAlphaFields(3));
@@ -746,7 +763,7 @@ namespace WaterToAirHeatPump {
         for (HPNum = 1; HPNum <= state.dataWaterToAirHeatPump->NumWatertoAirHPs; ++HPNum) {
 
             auto &heatPump = state.dataWaterToAirHeatPump->WatertoAirHP(HPNum);
-            if (heatPump.WAHPType == DataPlant::PlantEquipmentType::CoilWAHPCoolingParamEst) {
+            if (heatPump.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingParamEst) {
                 // COOLING COIL: Setup Report variables for the Heat Pump
                 SetupOutputVariable(state,
                                     "Cooling Coil Electricity Rate",
@@ -860,7 +877,7 @@ namespace WaterToAirHeatPump {
                                     OutputProcessor::TimeStepType::System,
                                     OutputProcessor::StoreType::Average,
                                     heatPump.Name);
-            } else if (heatPump.WAHPType == DataPlant::PlantEquipmentType::CoilWAHPHeatingParamEst) {
+            } else if (heatPump.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingParamEst) {
                 // HEATING COIL Setup Report variables for the Heat Pump
                 SetupOutputVariable(state,
                                     "Heating Coil Electricity Rate",
@@ -1007,7 +1024,7 @@ namespace WaterToAirHeatPump {
 
         if (state.dataWaterToAirHeatPump->MyPlantScanFlag(HPNum) && allocated(state.dataPlnt->PlantLoop)) {
             bool errFlag = false;
-            PlantUtilities::ScanPlantLoopsForObject(state, heatPump.Name, heatPump.WAHPType, heatPump.plantLoc, errFlag, _, _, _, _, _);
+            PlantUtilities::ScanPlantLoopsForObject(state, heatPump.Name, heatPump.coilPlantType, heatPump.plantLoc, errFlag, _, _, _, _, _);
 
             if (state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).FluidName == "WATER") {
                 if (heatPump.SourceSideUACoeff < Constant::rTinyValue) {
@@ -2410,6 +2427,36 @@ namespace WaterToAirHeatPump {
         return NodeNumber;
     }
 
+    int GetCoilIndex(EnergyPlusData &state, std::string const &CoilName)
+    {
+        // Obtains and Allocates WatertoAirHP related parameters from input file
+        if (state.dataWaterToAirHeatPump->GetCoilsInputFlag) { // First time subroutine has been entered
+            GetWatertoAirHPInput(state);
+            state.dataWaterToAirHeatPump->GetCoilsInputFlag = false;
+        }
+
+        return Util::FindItemInList(CoilName, state.dataWaterToAirHeatPump->WatertoAirHP);
+    }
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum) 
+    {
+        assert(coilNum > 0 && coilNum <= state.dataWaterToAirHeatPump->NumWatertoAirHPs);
+        auto &wahp = state.dataWaterToAirHeatPump->WatertoAirHP(coilNum);
+        return (wahp.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingParamEst) ? wahp.HeatingCapacity : wahp.CoolingCapacity;
+    }
+
+    int GetCoilInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataWaterToAirHeatPump->NumWatertoAirHPs);
+        return state.dataWaterToAirHeatPump->WatertoAirHP(coilNum).AirInletNodeNum;
+    }
+
+    int GetCoilOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataWaterToAirHeatPump->NumWatertoAirHPs);
+        return state.dataWaterToAirHeatPump->WatertoAirHP(coilNum).AirOutletNodeNum;
+    }
+  
 } // namespace WaterToAirHeatPump
 
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/WaterToAirHeatPump.hh b/src/EnergyPlus/WaterToAirHeatPump.hh
index 67303486901..e1107154fcb 100644
--- a/src/EnergyPlus/WaterToAirHeatPump.hh
+++ b/src/EnergyPlus/WaterToAirHeatPump.hh
@@ -77,8 +77,7 @@ namespace WaterToAirHeatPump {
     {
         // Members
         std::string Name;                       // Name of the Water to Air Heat pump
-        std::string WatertoAirHPType;           // Type of WatertoAirHP ie. Heating or Cooling
-        DataPlant::PlantEquipmentType WAHPType; // type of component in plant
+        DataPlant::PlantEquipmentType coilPlantType = DataPlant::PlantEquipmentType::Invalid; // type of component in plant
         std::string Refrigerant;                // Refrigerant name
         Fluid::RefrigProps *refrig = nullptr;
         bool SimFlag;
@@ -150,7 +149,7 @@ namespace WaterToAirHeatPump {
 
         // Default Constructor
         WatertoAirHPEquipConditions()
-            : WAHPType(DataPlant::PlantEquipmentType::Invalid), SimFlag(false), InletAirMassFlowRate(0.0), OutletAirMassFlowRate(0.0),
+            : SimFlag(false), InletAirMassFlowRate(0.0), OutletAirMassFlowRate(0.0),
               InletAirDBTemp(0.0), InletAirHumRat(0.0), OutletAirDBTemp(0.0), OutletAirHumRat(0.0), InletAirEnthalpy(0.0), OutletAirEnthalpy(0.0),
               InletWaterTemp(0.0), OutletWaterTemp(0.0), InletWaterMassFlowRate(0.0), OutletWaterMassFlowRate(0.0), DesignWaterMassFlowRate(0.0),
               DesignWaterVolFlowRate(0.0), InletWaterEnthalpy(0.0), OutletWaterEnthalpy(0.0), Power(0.0), Energy(0.0), QSensible(0.0), QLatent(0.0),
@@ -179,6 +178,17 @@ namespace WaterToAirHeatPump {
                          HVAC::CompressorOp compressorOp,
                          Real64 const PartLoadRatio);
 
+    void SimWatertoAirHP(EnergyPlusData &state,
+                         int const coilNum,                // Index for Component name
+                         Real64 const DesignAirflow,    // design air flow rate
+                         HVAC::FanOp const fanOp,       // cycling scheme--either continuous fan/cycling compressor or
+                         bool const FirstHVACIteration, // first iteration flag
+                         bool const InitFlag,           // initialization flag used to suppress property routine errors
+                         Real64 const SensLoad,         // sensible load
+                         Real64 const LatentLoad,       // latent load
+                         HVAC::CompressorOp compressorOp,
+                         Real64 const PartLoadRatio);
+  
     void GetWatertoAirHPInput(EnergyPlusData &state);
 
     void InitWatertoAirHP(EnergyPlusData &state,
@@ -225,6 +235,7 @@ namespace WaterToAirHeatPump {
                    Real64 &Temp // Temperature of the fluid
     );
 
+#ifdef OLD_API  
     int GetCoilIndex(EnergyPlusData &state,
                      std::string const &CoilType, // must match coil types in this module
                      std::string const &CoilName, // must match coil names for the coil type
@@ -248,7 +259,16 @@ namespace WaterToAirHeatPump {
                           std::string const &CoilName, // must match coil names for the coil type
                           bool &ErrorsFound            // set to true if problem
     );
+#endif // OLD_API
+  
+    int GetCoilIndex(EnergyPlusData &state, std::string const &CoilName);
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilInletNode(EnergyPlusData &state, int const coilNum);
 
+    int GetCoilOutletNode(EnergyPlusData &state, int const coilNum);
+  
 } // namespace WaterToAirHeatPump
 
 struct WaterToAirHeatPumpData : BaseGlobalStruct
diff --git a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc
index cf08ef5e12b..51bcc2cf3b4 100644
--- a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc
+++ b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc
@@ -106,8 +106,6 @@ namespace WaterToAirHeatPumpSimple {
     // State Energy Simulation Program. M.S. Thesis, Department of Mechanical and Aerospace Engineering,
     // Oklahoma State University. (downloadable from www.hvac.okstate.edu)
 
-    constexpr std::array<std::string_view, static_cast<int>(WatertoAirHP::Num)> WatertoAirHPNamesUC{"HEATING", "COOLING"};
-
     void SimWatertoAirHPSimple(EnergyPlusData &state,
                                std::string_view CompName, // Coil Name
                                int &CompIndex,            // Index for Component name
@@ -175,18 +173,41 @@ namespace WaterToAirHeatPumpSimple {
             }
         }
 
-        auto const &simpleWAHP = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum);
+        SimWatertoAirHPSimple(state,
+                              HPNum,
+                              SensLoad, 
+                              LatentLoad,
+                              fanOp,
+                              compressorOp,
+                              PartLoadRatio,
+                              FirstHVACIteration,
+                              OnOffAirFlowRatio);
 
-        if (simpleWAHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
+    }
+  
+    void SimWatertoAirHPSimple(EnergyPlusData &state,
+                               int const hpNum,
+                               Real64 const SensLoad,     // Sensible demand load [W]
+                               Real64 const LatentLoad,   // Latent demand load [W]
+                               HVAC::FanOp const fanOp,   // Continuous fan OR cycling compressor
+                               HVAC::CompressorOp const compressorOp,
+                               Real64 const PartLoadRatio,
+                               bool const FirstHVACIteration,
+                               Real64 const OnOffAirFlowRatio // ratio of comp on to comp off air flow rate
+    )
+    {
+        auto const &simpleWAHP = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(hpNum);
+
+        if (simpleWAHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
             // Cooling mode
-            InitSimpleWatertoAirHP(state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
-            CalcHPCoolingSimple(state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-            UpdateSimpleWatertoAirHP(state, HPNum);
-        } else if (simpleWAHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
+            InitSimpleWatertoAirHP(state, hpNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
+            CalcHPCoolingSimple(state, hpNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
+            UpdateSimpleWatertoAirHP(state, hpNum);
+        } else if (simpleWAHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
             // Heating mode
-            InitSimpleWatertoAirHP(state, HPNum, SensLoad, DataPrecisionGlobals::constant_zero, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
-            CalcHPHeatingSimple(state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-            UpdateSimpleWatertoAirHP(state, HPNum);
+            InitSimpleWatertoAirHP(state, hpNum, SensLoad, DataPrecisionGlobals::constant_zero, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
+            CalcHPHeatingSimple(state, hpNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
+            UpdateSimpleWatertoAirHP(state, hpNum);
         } else {
             ShowFatalError(state, "SimWatertoAirHPSimple: WatertoAir heatpump not in either HEATING or COOLING mode");
         }
@@ -297,8 +318,10 @@ namespace WaterToAirHeatPumpSimple {
             // ErrorsFound will be set to True if problem was found, left untouched otherwise
             GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, format("{} Name", CurrentModuleObject));
             simpleWAHP.Name = AlphArray(1);
-            simpleWAHP.WAHPType = WatertoAirHP::Cooling;
-            simpleWAHP.WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
+            simpleWAHP.coilType = HVAC::CoilType::CoolingWAHPSimple;
+            simpleWAHP.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
+            simpleWAHP.coilReportNum = ReportCoilSelection::getReportIndex(state, simpleWAHP.Name, simpleWAHP.coilType);
+            
             simpleWAHP.RatedAirVolFlowRate = NumArray(1);
             simpleWAHP.RatedWaterVolFlowRate = NumArray(2);
             simpleWAHP.RatedCapCoolTotal = NumArray(3);
@@ -528,8 +551,10 @@ namespace WaterToAirHeatPumpSimple {
             // ErrorsFound will be set to True if problem was found, left untouched otherwise
             GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, format("{} Name", CurrentModuleObject));
             simpleWAHP.Name = AlphArray(1);
-            simpleWAHP.WAHPType = WatertoAirHP::Heating;
-            simpleWAHP.WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
+            simpleWAHP.coilType = HVAC::CoilType::HeatingWAHPSimple;
+            simpleWAHP.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
+            simpleWAHP.coilReportNum = ReportCoilSelection::getReportIndex(state, simpleWAHP.Name, simpleWAHP.coilType);
+            
             simpleWAHP.RatedAirVolFlowRate = NumArray(1);
             simpleWAHP.RatedWaterVolFlowRate = NumArray(2);
             simpleWAHP.RatedCapHeat = NumArray(3);
@@ -703,7 +728,7 @@ namespace WaterToAirHeatPumpSimple {
 
         for (HPNum = 1; HPNum <= state.dataWaterToAirHeatPumpSimple->NumWatertoAirHPs; ++HPNum) {
             auto &simpleWAHP(state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum));
-            if (simpleWAHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
+            if (simpleWAHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
                 // COOLING COIL  Setup Report variables for the Heat Pump
                 SetupOutputVariable(state,
                                     "Cooling Coil Electricity Rate",
@@ -812,7 +837,7 @@ namespace WaterToAirHeatPumpSimple {
                                     OutputProcessor::StoreType::Average,
                                     simpleWAHP.Name);
 
-            } else if (simpleWAHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
+            } else if (simpleWAHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
                 // HEATING COIL Setup Report variables for the Heat Pump
                 SetupOutputVariable(state,
                                     "Heating Coil Electricity Rate",
@@ -965,7 +990,7 @@ namespace WaterToAirHeatPumpSimple {
         if (state.dataWaterToAirHeatPumpSimple->MyPlantScanFlag(HPNum) && allocated(state.dataPlnt->PlantLoop)) {
             bool errFlag = false;
             PlantUtilities::ScanPlantLoopsForObject(
-                state, simpleWatertoAirHP.Name, simpleWatertoAirHP.WAHPPlantType, simpleWatertoAirHP.plantLoc, errFlag, _, _, _, _, _);
+                state, simpleWatertoAirHP.Name, simpleWatertoAirHP.coilPlantType, simpleWatertoAirHP.plantLoc, errFlag, _, _, _, _, _);
             if (errFlag) {
                 ShowFatalError(state, "InitSimpleWatertoAirHP: Program terminated for previous conditions.");
             }
@@ -982,7 +1007,7 @@ namespace WaterToAirHeatPumpSimple {
 
         if (FirstHVACIteration) {
             if (state.dataWaterToAirHeatPumpSimple->SimpleHPTimeStepFlag(HPNum)) {
-                if (simpleWatertoAirHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
+                if (simpleWatertoAirHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
                     if (simpleWatertoAirHP.CompanionHeatingCoilNum > 0) {
                         if (simpleWatertoAirHP.WaterFlowMode) {
                             simpleWatertoAirHP.LastOperatingMode = HVAC::Cooling;
@@ -1023,7 +1048,7 @@ namespace WaterToAirHeatPumpSimple {
             }
         } else {
             state.dataWaterToAirHeatPumpSimple->SimpleHPTimeStepFlag(HPNum) = true;
-            if (simpleWatertoAirHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
+            if (simpleWatertoAirHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
                 if (simpleWatertoAirHP.CompanionHeatingCoilNum > 0)
                     state.dataWaterToAirHeatPumpSimple->SimpleHPTimeStepFlag(simpleWatertoAirHP.CompanionHeatingCoilNum) = true;
             } else {
@@ -1075,7 +1100,7 @@ namespace WaterToAirHeatPumpSimple {
                                                        simpleWatertoAirHP.WaterInletNodeNum,
                                                        simpleWatertoAirHP.WaterOutletNodeNum);
 
-                    if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating && simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
+                    if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple && simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
                         state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionCoolingCoilNum).DesignWaterMassFlowRate =
                             rho *
                             state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionCoolingCoilNum).RatedWaterVolFlowRate;
@@ -1133,7 +1158,7 @@ namespace WaterToAirHeatPumpSimple {
             simpleWatertoAirHP.WaterMassFlowRate = 0.0;
             simpleWatertoAirHP.AirMassFlowRate = 0.0;
             if ((simpleWatertoAirHP.WaterCyclingMode) == HVAC::WaterFlow::Constant) {
-                if (simpleWatertoAirHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
+                if (simpleWatertoAirHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) {
                     if (simpleWatertoAirHP.CompanionHeatingCoilNum > 0) {
                         if (state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionHeatingCoilNum).QLoadTotal > 0.0) {
                             // do nothing, there will be flow through this coil
@@ -1147,7 +1172,7 @@ namespace WaterToAirHeatPumpSimple {
                             simpleWatertoAirHP.WaterMassFlowRate = simpleWatertoAirHP.DesignWaterMassFlowRate;
                         }
                     }
-                } else if (simpleWatertoAirHP.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
+                } else if (simpleWatertoAirHP.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
                     // It's a heating coil
                     if (simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
                         if (state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionCoolingCoilNum).QLoadTotal > 0.0) {
@@ -1330,7 +1355,6 @@ namespace WaterToAirHeatPumpSimple {
         RatedCapHeatUser = 0.0;
         RatedWaterVolFlowRateDes = 0.0;
         RatedWaterVolFlowRateUser = 0.0;
-        std::string CompType = format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]);
 
         if (simpleWatertoAirHP.RatedAirVolFlowRate == DataSizing::AutoSize) {
             IsAutoSize = true;
@@ -1341,14 +1365,14 @@ namespace WaterToAirHeatPumpSimple {
                 if (simpleWatertoAirHP.RatedAirVolFlowRate > 0.0) {
                     BaseSizer::reportSizerOutput(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name,
                         "User-Specified Rated Air Flow Rate [m3/s]",
                         simpleWatertoAirHP.RatedAirVolFlowRate);
                 }
             } else {
                 CheckSysSizing(state,
-                               format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                               HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                simpleWatertoAirHP.Name);
                 if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
                     RatedAirVolFlowRateDes = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
@@ -1364,14 +1388,14 @@ namespace WaterToAirHeatPumpSimple {
                 if (simpleWatertoAirHP.RatedAirVolFlowRate > 0.0) {
                     BaseSizer::reportSizerOutput(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name,
                         "User-Specified Rated Air Flow Rate [m3/s]",
                         simpleWatertoAirHP.RatedAirVolFlowRate);
                 }
             } else {
                 CheckZoneSizing(state,
-                                format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                                HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                 simpleWatertoAirHP.Name);
                 RatedAirVolFlowRateDes = max(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesCoolVolFlow,
                                              state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatVolFlow);
@@ -1387,7 +1411,7 @@ namespace WaterToAirHeatPumpSimple {
                 simpleWatertoAirHP.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
                 BaseSizer::reportSizerOutput(
                     state,
-                    format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                    HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                     simpleWatertoAirHP.Name,
                     "Design Size Rated Air Flow Rate [m3/s]",
                     RatedAirVolFlowRateDes);
@@ -1396,7 +1420,7 @@ namespace WaterToAirHeatPumpSimple {
                     RatedAirVolFlowRateUser = simpleWatertoAirHP.RatedAirVolFlowRate;
                     BaseSizer::reportSizerOutput(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name,
                         "Design Size Rated Air Flow Rate [m3/s]",
                         RatedAirVolFlowRateDes,
@@ -1407,8 +1431,8 @@ namespace WaterToAirHeatPumpSimple {
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(
                                 state,
-                                format("SizeHVACWaterToAir: Potential issue with equipment sizing for coil {}:WATERTOAIRHEATPUMP:EQUATIONFIT \"{}\"",
-                                       WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                format("SizeHVACWaterToAir: Potential issue with equipment sizing for coil {} \"{}\"",
+                                       HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                        simpleWatertoAirHP.Name));
                             ShowContinueError(state, format("User-Specified Rated Air Volume Flow Rate of {:.5R} [m3/s]", RatedAirVolFlowRateUser));
                             ShowContinueError(state,
@@ -1426,7 +1450,7 @@ namespace WaterToAirHeatPumpSimple {
 
         Real64 FanCoolLoad = 0.0;
         Real64 FanHeatLoad = FanCoolLoad;
-        if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Cooling) {
+        if (simpleWatertoAirHP.coilType == HVAC::CoilType::CoolingWAHPSimple) {
             // size rated total cooling capacity
             if (simpleWatertoAirHP.RatedCapCoolTotal == DataSizing::AutoSize) {
                 RatedCapCoolTotalAutoSized = true;
@@ -1438,7 +1462,7 @@ namespace WaterToAirHeatPumpSimple {
                     if (simpleWatertoAirHP.RatedCapCoolTotal > 0.0) {
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "User-Specified Rated Total Cooling Capacity [W]",
                             simpleWatertoAirHP.RatedCapCoolTotal);
@@ -1446,7 +1470,7 @@ namespace WaterToAirHeatPumpSimple {
                 } else {
                     CheckSysSizing(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name);
                     if (CoolingAirVolFlowRateDes > 0.0) {
                         VolFlowRate = CoolingAirVolFlowRateDes;
@@ -1522,7 +1546,7 @@ namespace WaterToAirHeatPumpSimple {
                         ratioTWB = (MixWetBulb + state.dataWaterToAirHeatPumpSimple->CelsiustoKelvin) / Tref;
                         PltSizNum = PlantUtilities::MyPlantSizingIndex(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             simpleWatertoAirHP.WaterInletNodeNum,
                             simpleWatertoAirHP.WaterOutletNodeNum,
@@ -1535,8 +1559,8 @@ namespace WaterToAirHeatPumpSimple {
                             ShowSevereError(state, "Autosizing of total cooling capacity requires a loop Sizing:Plant object");
                             ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
                             ShowContinueError(state,
-                                              format("Occurs in COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT Object={}",
-                                                     WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                              format("Occurs in {} Object={}",
+                                                     HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                                      simpleWatertoAirHP.Name));
                             ratioTS = 0.0; // Clang complains it is used uninitialized if you don't give it a value
                             ErrorsFound = true;
@@ -1554,11 +1578,11 @@ namespace WaterToAirHeatPumpSimple {
                         // conditions
                         RatedCapCoolTotalDes = (PeakTotCapTempModFac > 0.0) ? CoolCapAtPeak / PeakTotCapTempModFac : CoolCapAtPeak;
                         // reporting
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                            state, simpleWatertoAirHP.Name, CompType, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, simpleWatertoAirHP.Name, CompType, MixHumRat);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, simpleWatertoAirHP.Name, CompType, SupTemp);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(state, simpleWatertoAirHP.Name, CompType, SupHumRat);
+                        ReportCoilSelection::setCoilEntAirTemp(
+                             state, simpleWatertoAirHP.coilReportNum, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
+                        ReportCoilSelection::setCoilEntAirHumRat(state, simpleWatertoAirHP.coilReportNum, MixHumRat);
+                        ReportCoilSelection::setCoilLvgAirTemp(state, simpleWatertoAirHP.coilReportNum, SupTemp);
+                        ReportCoilSelection::setCoilLvgAirHumRat(state, simpleWatertoAirHP.coilReportNum, SupHumRat);
                     } else {
                         RatedCapCoolTotalDes = 0.0;
                     }
@@ -1569,7 +1593,7 @@ namespace WaterToAirHeatPumpSimple {
                     if (simpleWatertoAirHP.RatedCapCoolTotal > 0.0) {
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "User-Specified Rated Total Cooling Capacity [W]",
                             simpleWatertoAirHP.RatedCapCoolTotal);
@@ -1577,7 +1601,7 @@ namespace WaterToAirHeatPumpSimple {
                 } else {
                     CheckZoneSizing(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name);
                     if (CoolingAirVolFlowRateDes > 0.0) {
                         VolFlowRate = CoolingAirVolFlowRateDes;
@@ -1652,7 +1676,7 @@ namespace WaterToAirHeatPumpSimple {
                         ratioTWB = (MixWetBulb + state.dataWaterToAirHeatPumpSimple->CelsiustoKelvin) / Tref;
                         PltSizNum = PlantUtilities::MyPlantSizingIndex(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNames[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             simpleWatertoAirHP.WaterInletNodeNum,
                             simpleWatertoAirHP.WaterOutletNodeNum,
@@ -1666,7 +1690,7 @@ namespace WaterToAirHeatPumpSimple {
                             ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
                             ShowContinueError(state,
                                               format("Occurs in COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT Object={}",
-                                                     WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                                     HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                                      simpleWatertoAirHP.Name));
                             ratioTS = 0.0; // Clang complains it is used uninitialized if you don't give it a value
                             ErrorsFound = true;
@@ -1684,11 +1708,11 @@ namespace WaterToAirHeatPumpSimple {
                         // conditions
                         RatedCapCoolTotalDes = (PeakTotCapTempModFac > 0.0) ? CoolCapAtPeak / PeakTotCapTempModFac : CoolCapAtPeak;
                         // reporting
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
-                            state, simpleWatertoAirHP.Name, CompType, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(state, simpleWatertoAirHP.Name, CompType, MixHumRat);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, simpleWatertoAirHP.Name, CompType, SupTemp);
-                        state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(state, simpleWatertoAirHP.Name, CompType, SupHumRat);
+                        ReportCoilSelection::setCoilEntAirTemp(
+                            state, simpleWatertoAirHP.coilReportNum, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
+                        ReportCoilSelection::setCoilEntAirHumRat(state, simpleWatertoAirHP.coilReportNum, MixHumRat);
+                        ReportCoilSelection::setCoilLvgAirTemp(state, simpleWatertoAirHP.coilReportNum, SupTemp);
+                        ReportCoilSelection::setCoilLvgAirHumRat(state, simpleWatertoAirHP.coilReportNum, SupHumRat);
                     } else {
                         RatedCapCoolTotalDes = 0.0;
                     }
@@ -1698,7 +1722,7 @@ namespace WaterToAirHeatPumpSimple {
                 }
             }
             // size rated sensible cooling capacity
-            if (simpleWatertoAirHP.RatedCapCoolSens == DataSizing::AutoSize && simpleWatertoAirHP.WAHPType == WatertoAirHP::Cooling) {
+            if (simpleWatertoAirHP.RatedCapCoolSens == DataSizing::AutoSize && simpleWatertoAirHP.coilType == HVAC::CoilType::CoolingWAHPSimple) {
                 RatedCapCoolSensAutoSized = true;
             }
             if (SizingDesRunThisAirSys || SizingDesRunThisZone) HardSizeNoDesRun = false;
@@ -1708,7 +1732,7 @@ namespace WaterToAirHeatPumpSimple {
                     if (simpleWatertoAirHP.RatedCapCoolSens > 0.0) {
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "User-Specified Rated Sensible Cooling Capacity [W]",
                             simpleWatertoAirHP.RatedCapCoolSens);
@@ -1716,7 +1740,7 @@ namespace WaterToAirHeatPumpSimple {
                 } else {
                     CheckSysSizing(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNames[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name);
                     if (CoolingAirVolFlowRateDes > 0.0) {
                         VolFlowRate = CoolingAirVolFlowRateDes;
@@ -1780,7 +1804,7 @@ namespace WaterToAirHeatPumpSimple {
                         ratioTWB = (MixWetBulb + state.dataWaterToAirHeatPumpSimple->CelsiustoKelvin) / Tref;
                         PltSizNum = PlantUtilities::MyPlantSizingIndex(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             simpleWatertoAirHP.WaterInletNodeNum,
                             simpleWatertoAirHP.WaterOutletNodeNum,
@@ -1794,7 +1818,7 @@ namespace WaterToAirHeatPumpSimple {
                             ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
                             ShowContinueError(state,
                                               format("Occurs in COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT Object={}",
-                                                     WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                                     HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                                      simpleWatertoAirHP.Name));
                             ErrorsFound = true;
                         }
@@ -1821,7 +1845,7 @@ namespace WaterToAirHeatPumpSimple {
                     if (simpleWatertoAirHP.RatedCapCoolSens > 0.0) {
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "User-Specified Rated Sensible Cooling Capacity [W]",
                             simpleWatertoAirHP.RatedCapCoolSens);
@@ -1829,7 +1853,7 @@ namespace WaterToAirHeatPumpSimple {
                 } else {
                     CheckZoneSizing(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name);
                     if (CoolingAirVolFlowRateDes > 0.0) {
                         VolFlowRate = CoolingAirVolFlowRateDes;
@@ -1888,7 +1912,7 @@ namespace WaterToAirHeatPumpSimple {
                         ratioTWB = (MixWetBulb + state.dataWaterToAirHeatPumpSimple->CelsiustoKelvin) / Tref;
                         PltSizNum = PlantUtilities::MyPlantSizingIndex(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             simpleWatertoAirHP.WaterInletNodeNum,
                             simpleWatertoAirHP.WaterOutletNodeNum,
@@ -1902,7 +1926,7 @@ namespace WaterToAirHeatPumpSimple {
                             ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
                             ShowContinueError(state,
                                               format("Occurs in COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT Object={}",
-                                                     WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                                     HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                                      simpleWatertoAirHP.Name));
                             ErrorsFound = true;
                         }
@@ -1937,7 +1961,7 @@ namespace WaterToAirHeatPumpSimple {
                     if (simpleWatertoAirHP.CompanionHeatingCoilNum > 0) {
                         auto const &companionHeatingCoil =
                             state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionHeatingCoilNum);
-                        if (companionHeatingCoil.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
+                        if (companionHeatingCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
                             companionHeatingCoil.RatedCapHeat > 0) {
                             // case 1: companion heating coil has a user-specified capacity
                             // or has already been sized
@@ -1973,7 +1997,7 @@ namespace WaterToAirHeatPumpSimple {
                             }
                             // Set the global DX cooling coil capacity variable for use by other objects
                             state.dataSize->DXCoolCap = simpleWatertoAirHP.RatedCapCoolTotal;
-                        } else if (companionHeatingCoil.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
+                        } else if (companionHeatingCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
                                    companionHeatingCoil.RatedCapHeat == DataSizing::AutoSize) {
                             // case 2: companion heating coil has not already been sized
                             // we only pass the rated total cooling capacity determined
@@ -1983,7 +2007,7 @@ namespace WaterToAirHeatPumpSimple {
                             // no capcity adjustment based on system flow because the capacity could change
                             // once the heating coil has been sized
                             state.dataSize->DXCoolCap = RatedCapCoolTotalDes;
-                        } else if (companionHeatingCoil.WAHPPlantType != DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
+                        } else if (companionHeatingCoil.coilPlantType != DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit) {
                             // case 3: companion heating coil is not of the "equationfit" type and hence doesn't use the rated heating to cooling
                             // coil capacity ratio
                             // adjust for system air flow -- capacity is based on cooling design day calcs
@@ -2009,7 +2033,7 @@ namespace WaterToAirHeatPumpSimple {
                     if (simpleWatertoAirHP.RatedCapCoolTotal != DataSizing::AutoSize) {
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "Design Size Rated Total Cooling Capacity [W]",
                             simpleWatertoAirHP.RatedCapCoolTotal);
@@ -2027,7 +2051,7 @@ namespace WaterToAirHeatPumpSimple {
                         simpleWatertoAirHP.RatedPowerCool = simpleWatertoAirHP.RatedCapCoolTotal / simpleWatertoAirHP.RatedCOPCoolAtRatedCdts;
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNames[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "Design Size Rated Total Cooling Capacity [W]",
                             RatedCapCoolTotalDes,
@@ -2039,7 +2063,7 @@ namespace WaterToAirHeatPumpSimple {
                                 ShowMessage(
                                     state,
                                     format("SizeHVACWaterToAir: Potential issue with equipment sizing for coil {}:WATERTOAIRHEATPUMP:EQUATIONFIT {}",
-                                           WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                           HVAC::coilTypeNames[(int)simpleWatertoAirHP.coilType],
                                            simpleWatertoAirHP.Name));
                                 ShowContinueError(state, format("User-Specified Rated Total Cooling Capacity of {:.2R} [W]", RatedCapCoolTotalUser));
                                 ShowContinueError(
@@ -2092,9 +2116,8 @@ namespace WaterToAirHeatPumpSimple {
                 OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilNomEff, simpleWatertoAirHP.Name, 0.0);
             }
             if (simpleWatertoAirHP.RatedCapCoolTotal != DataSizing::AutoSize) {
-                state.dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(state,
-                                                                                           simpleWatertoAirHP.Name,
-                                                                                           CompType,
+                ReportCoilSelection::setCoilCoolingCapacity(state,
+                                                                                           simpleWatertoAirHP.coilReportNum,
                                                                                            simpleWatertoAirHP.RatedCapCoolTotal,
                                                                                            RatedCapCoolTotalAutoSized,
                                                                                            state.dataSize->CurSysNum,
@@ -2112,7 +2135,7 @@ namespace WaterToAirHeatPumpSimple {
                     if (simpleWatertoAirHP.RatedCapCoolTotal != DataSizing::AutoSize) {
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "Design Size Rated Sensible Cooling Capacity [W]",
                             RatedCapCoolSensDes);
@@ -2122,7 +2145,7 @@ namespace WaterToAirHeatPumpSimple {
                         RatedCapCoolSensUser = simpleWatertoAirHP.RatedCapCoolSens;
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "Design Size Rated Sensible Cooling Capacity [W]",
                             RatedCapCoolSensDes,
@@ -2134,7 +2157,7 @@ namespace WaterToAirHeatPumpSimple {
                                 ShowMessage(
                                     state,
                                     format("SizeHVACWaterToAir: Potential issue with equipment sizing for coil {}:WATERTOAIRHEATPUMP:EQUATIONFIT {}",
-                                           WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                           HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                            simpleWatertoAirHP.Name));
                                 ShowContinueError(state,
                                                   format("User-Specified Rated Sensible Cooling Capacity of {:.2R} [W]", RatedCapCoolSensUser));
@@ -2171,10 +2194,7 @@ namespace WaterToAirHeatPumpSimple {
             // test autosized sensible and total cooling capacity for total > sensible
             if ((RatedCapCoolSensAutoSized && RatedCapCoolTotalAutoSized) || RatedCapCoolSensAutoSized) {
                 if (simpleWatertoAirHP.RatedCapCoolSensDesAtRatedCdts > simpleWatertoAirHP.RatedCapCoolAtRatedCdts) {
-                    ShowWarningError(state,
-                                     format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT \"{}\"",
-                                            WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
-                                            simpleWatertoAirHP.Name));
+                    ShowWarningError(state,  format("{} \"{}\"", HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType], simpleWatertoAirHP.Name));
                     ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
                     ShowContinueError(state, "Both of these capacity inputs have been autosized.");
                     ShowContinueError(
@@ -2215,10 +2235,7 @@ namespace WaterToAirHeatPumpSimple {
                 }
             } else if (RatedCapCoolTotalAutoSized) {
                 if (simpleWatertoAirHP.RatedCapCoolSensDesAtRatedCdts > simpleWatertoAirHP.RatedCapCoolAtRatedCdts) {
-                    ShowWarningError(state,
-                                     format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT \"{}\"",
-                                            WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
-                                            simpleWatertoAirHP.Name));
+                    ShowWarningError(state, format("{} \"{}\"", HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType], simpleWatertoAirHP.Name));
                     ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
                     ShowContinueError(state, "Only the Rated total capacity input is autosized, consider autosizing both inputs.");
                     ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", simpleWatertoAirHP.RatedCapCoolSensDesAtRatedCdts));
@@ -2256,7 +2273,7 @@ namespace WaterToAirHeatPumpSimple {
 
         } // Cooling Coil
 
-        if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating) {
+        if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple) {
             // size rated heating capacity
             IsAutoSize = false;
             if (simpleWatertoAirHP.RatedCapHeat == DataSizing::AutoSize) {
@@ -2267,7 +2284,7 @@ namespace WaterToAirHeatPumpSimple {
                 if (state.dataSize->CurSysNum > 0) {
                     CheckSysSizing(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name);
                     if (HeatingAirVolFlowRateDes > 0.0) {
                         VolFlowRate = HeatingAirVolFlowRateDes;
@@ -2336,7 +2353,7 @@ namespace WaterToAirHeatPumpSimple {
                         HeatratioTDB = (HeatMixTemp + state.dataWaterToAirHeatPumpSimple->CelsiustoKelvin) / Tref;
                         PltSizNum = PlantUtilities::MyPlantSizingIndex(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             simpleWatertoAirHP.WaterInletNodeNum,
                             simpleWatertoAirHP.WaterOutletNodeNum,
@@ -2349,8 +2366,8 @@ namespace WaterToAirHeatPumpSimple {
                             ShowSevereError(state, "Autosizing of heating capacity requires a loop Sizing:Plant object");
                             ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
                             ShowContinueError(state,
-                                              format("Occurs in COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT Object={}",
-                                                     WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                              format("Occurs in {} Object={}",
+                                                     HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                                      simpleWatertoAirHP.Name));
                             HeatratioTS = 0.0; // Clang complains it is used uninitialized if you don't give it a value
                             ErrorsFound = true;
@@ -2384,7 +2401,7 @@ namespace WaterToAirHeatPumpSimple {
                 } else if (state.dataSize->CurZoneEqNum > 0) {
                     CheckZoneSizing(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name);
                     if (HeatingAirVolFlowRateDes > 0.0) {
                         VolFlowRate = HeatingAirVolFlowRateDes;
@@ -2440,7 +2457,7 @@ namespace WaterToAirHeatPumpSimple {
                         HeatratioTDB = (HeatMixTemp + state.dataWaterToAirHeatPumpSimple->CelsiustoKelvin) / Tref;
                         PltSizNum = PlantUtilities::MyPlantSizingIndex(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             simpleWatertoAirHP.WaterInletNodeNum,
                             simpleWatertoAirHP.WaterOutletNodeNum,
@@ -2453,8 +2470,8 @@ namespace WaterToAirHeatPumpSimple {
                             ShowSevereError(state, "Autosizing of heating capacity requires a loop Sizing:Plant object");
                             ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
                             ShowContinueError(state,
-                                              format("Occurs in COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT Object={}",
-                                                     WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                              format("Occurs in {} Object={}",
+                                                     HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                                      simpleWatertoAirHP.Name));
                             HeatratioTS = 0.0; // Clang complains it is used uninitialized if you don't give it a value
                             ErrorsFound = true;
@@ -2502,7 +2519,7 @@ namespace WaterToAirHeatPumpSimple {
                 simpleWatertoAirHP.RatedCapHeatAtRatedCdts = RatedCapHeatDes * RatedHeatCapTempModFac;
                 if (simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
                     auto &companionCoolingCoil(state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionCoolingCoilNum));
-                    if (companionCoolingCoil.WAHPPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit &&
+                    if (companionCoolingCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit &&
                         companionCoolingCoil.RatedCapCoolTotal == DataSizing::AutoSize) {
                         // case 1: companion coil is also of EquationFit type and is being autosized
                         RatedCapCoolTotalDes = state.dataSize->DXCoolCap;
@@ -2569,17 +2586,17 @@ namespace WaterToAirHeatPumpSimple {
                             state, state.dataOutRptPredefined->pdchCoolCoilTotCap, companionCoolingCoil.Name, RatedCapCoolTotalDes);
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(companionCoolingCoil.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)companionCoolingCoil.coilType],
                             companionCoolingCoil.Name,
                             "Design Size Rated Total Cooling Capacity [W]",
                             companionCoolingCoil.RatedCapCoolTotal);
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(companionCoolingCoil.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)companionCoolingCoil.coilType],
                             companionCoolingCoil.Name,
                             "Design Size Rated Sensible Cooling Capacity [W]",
                             companionCoolingCoil.RatedCapCoolSens);
-                    } else if (companionCoolingCoil.WAHPPlantType ==
+                    } else if (companionCoolingCoil.coilPlantType ==
                                DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit) { // case 2: companion coil is of EquationFit type but is
                                                                                             // not autosized
                         RatedCapHeatDes = companionCoolingCoil.RatedCapCoolTotal * simpleWatertoAirHP.RatioRatedHeatRatedTotCoolCap;
@@ -2607,7 +2624,7 @@ namespace WaterToAirHeatPumpSimple {
                     state, state.dataOutRptPredefined->pdchWAHPRatedWtrT, simpleWatertoAirHP.Name, simpleWatertoAirHP.RatedEntWaterTemp);
                 BaseSizer::reportSizerOutput(
                     state,
-                    format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                    HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                     simpleWatertoAirHP.Name,
                     "Design Size Rated Heating Capacity [W]",
                     simpleWatertoAirHP.RatedCapHeat);
@@ -2626,7 +2643,7 @@ namespace WaterToAirHeatPumpSimple {
                     RatedCapHeatUser = simpleWatertoAirHP.RatedCapHeat;
                     BaseSizer::reportSizerOutput(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                         simpleWatertoAirHP.Name,
                         "Design Size Rated Heating Capacity [W]",
                         RatedCapHeatDes,
@@ -2636,8 +2653,8 @@ namespace WaterToAirHeatPumpSimple {
                         if ((std::abs(RatedCapHeatDes - RatedCapHeatUser) / RatedCapHeatUser) > state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(
                                 state,
-                                format("SizeHVACWaterToAir: Potential issue with equipment sizing for coil {}:WATERTOAIRHEATPUMP:EQUATIONFIT {}",
-                                       WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
+                                format("SizeHVACWaterToAir: Potential issue with equipment sizing for coil {} {}",
+                                       HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                                        simpleWatertoAirHP.Name));
                             ShowContinueError(state, format("User-Specified Rated Heating Capacity of {:.2R} [W]", RatedCapHeatUser));
                             ShowContinueError(state, format("differs from Design Size Rated Heating Capacity of {:.2R} [W]", RatedCapHeatDes));
@@ -2650,7 +2667,7 @@ namespace WaterToAirHeatPumpSimple {
                         RatedCapHeatUser = simpleWatertoAirHP.RatedCapHeat;
                         BaseSizer::reportSizerOutput(
                             state,
-                            format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                            HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                             simpleWatertoAirHP.Name,
                             "User-Specified Rated Heating Capacity [W]",
                             RatedCapHeatUser);
@@ -2663,20 +2680,17 @@ namespace WaterToAirHeatPumpSimple {
                 simpleWatertoAirHP.RatedPowerHeatAtRatedCdts = 0; // should be RatedPowerHeat?
             }
             // Check that heat pump heating capacity is within 20% of cooling capacity. Check only for heating coil and report both.
-            if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating && simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
+            if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple && simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
                 auto &companionCoolingCoil(state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionCoolingCoilNum));
                 if (companionCoolingCoil.RatedCapCoolTotal > 0.0) {
 
                     if (std::abs(companionCoolingCoil.RatedCapCoolTotal - simpleWatertoAirHP.RatedCapHeat) / companionCoolingCoil.RatedCapCoolTotal >
                         0.2) {
 
-                        ShowWarningError(state,
-                                         format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT {}",
-                                                WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
-                                                simpleWatertoAirHP.Name));
+                        ShowWarningError(state, format("{} {}", HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType], simpleWatertoAirHP.Name));
                         ShowContinueError(state,
-                                          format("...used with COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT {}",
-                                                 companionCoolingCoil.WAHPType,
+                                          format("...used with {} {}",
+                                                 HVAC::coilTypeNamesUC[(int)companionCoolingCoil.coilType],
                                                  companionCoolingCoil.Name));
                         ShowContinueError(state, "...heating capacity is disproportionate (> 20% different) to total cooling capacity");
                         ShowContinueError(state, format("...heating capacity = {:.3T} W", simpleWatertoAirHP.RatedCapHeat));
@@ -2685,10 +2699,9 @@ namespace WaterToAirHeatPumpSimple {
                 }
             }
 
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(
+            ReportCoilSelection::setCoilHeatingCapacity(
                 state,
-                simpleWatertoAirHP.Name,
-                format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                simpleWatertoAirHP.coilReportNum,
                 RatedCapHeatDes,
                 IsAutoSize,
                 state.dataSize->CurSysNum,
@@ -2702,7 +2715,7 @@ namespace WaterToAirHeatPumpSimple {
         } // Heating
 
         // size/report rated efficiency and power
-        if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Cooling) {
+        if (simpleWatertoAirHP.coilType == HVAC::CoilType::CoolingWAHPSimple) {
             if (simpleWatertoAirHP.RatedPowerCool > 0) {
                 OutputReportPredefined::PreDefTableEntry(state,
                                                          state.dataOutRptPredefined->pdchCoolCoilNomEff,
@@ -2722,7 +2735,7 @@ namespace WaterToAirHeatPumpSimple {
                                                                  simpleWatertoAirHP.RatedPowerCoolAtRatedCdts);
                 }
             }
-        } else if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating) {
+        } else if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple) {
             // heating coil power
             simpleWatertoAirHP.RatedPowerHeatAtRatedCdts = simpleWatertoAirHP.RatedCapHeatAtRatedCdts / simpleWatertoAirHP.RatedCOPHeatAtRatedCdts;
             if (simpleWatertoAirHP.RatedPowerHeat > 0) {
@@ -2782,7 +2795,7 @@ namespace WaterToAirHeatPumpSimple {
         if (IsAutoSize) {
             PltSizNum = PlantUtilities::MyPlantSizingIndex(
                 state,
-                format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                HVAC::coilTypeNames[(int)simpleWatertoAirHP.coilType],
                 simpleWatertoAirHP.Name,
                 simpleWatertoAirHP.WaterInletNodeNum,
                 simpleWatertoAirHP.WaterOutletNodeNum,
@@ -2795,9 +2808,9 @@ namespace WaterToAirHeatPumpSimple {
                 Cp = state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum)
                          .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
 
-                if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating) {
+                if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple) {
                     RatedWaterVolFlowRateDes = simpleWatertoAirHP.RatedCapHeat / (state.dataSize->PlantSizData(PltSizNum).DeltaT * Cp * rho);
-                } else if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Cooling) {
+                } else if (simpleWatertoAirHP.coilType == HVAC::CoilType::CoolingWAHPSimple) {
                     //       use companion heating coil capacity to calculate volumetric flow rate
                     if (simpleWatertoAirHP.CompanionHeatingCoilNum > 0) {
                         auto const &companionHeatingCoil =
@@ -2816,35 +2829,33 @@ namespace WaterToAirHeatPumpSimple {
             } else {
                 ShowSevereError(state, "Autosizing of water flow requires a loop Sizing:Plant object");
                 ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
-                ShowContinueError(state,
-                                  format("Occurs in COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT Object={}",
-                                         WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)],
-                                         simpleWatertoAirHP.Name));
+                ShowContinueError(state, format("Occurs in  Object={}", HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType], simpleWatertoAirHP.Name));
+                ErrorsFound = true;
             }
 
             if (SystemCapacity != DataSizing::AutoSize) {
                 simpleWatertoAirHP.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
                 BaseSizer::reportSizerOutput(
                     state,
-                    format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                    HVAC::coilTypeNamesUC[(int)simpleWatertoAirHP.coilType],
                     simpleWatertoAirHP.Name,
                     "Design Size Rated Water Flow Rate [m3/s]",
                     RatedWaterVolFlowRateDes);
-                if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating && simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
+                if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple && simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
                     auto &companionCoolingCoil(state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionCoolingCoilNum));
                     companionCoolingCoil.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
                     BaseSizer::reportSizerOutput(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(companionCoolingCoil.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)companionCoolingCoil.coilType],
                         companionCoolingCoil.Name,
                         "Design Size Rated Water Flow Rate [m3/s]",
                         RatedWaterVolFlowRateDes);
-                } else if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Cooling && simpleWatertoAirHP.CompanionHeatingCoilNum > 0) {
+                } else if (simpleWatertoAirHP.coilType == HVAC::CoilType::CoolingWAHPSimple && simpleWatertoAirHP.CompanionHeatingCoilNum > 0) {
                     auto &companionHeatingCoil(state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(simpleWatertoAirHP.CompanionHeatingCoilNum));
                     companionHeatingCoil.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
                     BaseSizer::reportSizerOutput(
                         state,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(companionHeatingCoil.WAHPType)]),
+                        HVAC::coilTypeNamesUC[(int)companionHeatingCoil.coilType],
                         companionHeatingCoil.Name,
                         "Design Size Rated Water Flow Rate [m3/s]",
                         RatedWaterVolFlowRateDes);
@@ -2855,7 +2866,7 @@ namespace WaterToAirHeatPumpSimple {
                 RatedWaterVolFlowRateUser = simpleWatertoAirHP.RatedWaterVolFlowRate;
                 BaseSizer::reportSizerOutput(
                     state,
-                    format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                    HVAC::coilTypeNames[(int)simpleWatertoAirHP.coilType],
                     simpleWatertoAirHP.Name,
                     "Design Size Rated Water Flow Rate [m3/s]",
                     RatedWaterVolFlowRateDes,
@@ -2866,7 +2877,7 @@ namespace WaterToAirHeatPumpSimple {
                         state.dataSize->AutoVsHardSizingThreshold) {
                         ShowMessage(state,
                                     format("SizeHVACWaterToAir: Potential issue with equipment sizing for coil {}:WATERTOAIRHEATPUMP:EQUATIONFIT {}",
-                                           simpleWatertoAirHP.WAHPType,
+                                           simpleWatertoAirHP.coilType,
                                            simpleWatertoAirHP.Name));
                         ShowContinueError(state, format("User-Specified Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateUser));
                         ShowContinueError(state, format("differs from Design Size Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateDes));
@@ -2880,7 +2891,7 @@ namespace WaterToAirHeatPumpSimple {
         // Save component design water volumetric flow rate.
         // Use 1/2 flow since both cooling and heating coil will save flow yet only 1 will operate at a time
         if (simpleWatertoAirHP.RatedWaterVolFlowRate > 0.0) {
-            if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating) {
+            if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple) {
                 PlantUtilities::RegisterPlantCompDesignFlow(
                     state, simpleWatertoAirHP.WaterInletNodeNum, 0.5 * simpleWatertoAirHP.RatedWaterVolFlowRate);
                 if (simpleWatertoAirHP.CompanionCoolingCoilNum > 0) {
@@ -2888,7 +2899,7 @@ namespace WaterToAirHeatPumpSimple {
                     PlantUtilities::RegisterPlantCompDesignFlow(
                         state, companionCoolingCoil.WaterInletNodeNum, 0.5 * simpleWatertoAirHP.RatedWaterVolFlowRate);
                 }
-            } else if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Cooling) {
+            } else if (simpleWatertoAirHP.coilType == HVAC::CoilType::CoolingWAHPSimple) {
                 PlantUtilities::RegisterPlantCompDesignFlow(
                     state, simpleWatertoAirHP.WaterInletNodeNum, 0.5 * simpleWatertoAirHP.RatedWaterVolFlowRate);
             }
@@ -3530,20 +3541,18 @@ namespace WaterToAirHeatPumpSimple {
         if (simpleWatertoAirHP.reportCoilFinalSizes) {
             if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
 
-                if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Cooling) {
-                    state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(
+                if (simpleWatertoAirHP.coilType == HVAC::CoilType::CoolingWAHPSimple) {
+                    ReportCoilSelection::setCoilFinalSizes(
                         state,
-                        simpleWatertoAirHP.Name,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        simpleWatertoAirHP.coilReportNum,
                         simpleWatertoAirHP.RatedCapCoolTotal,
                         simpleWatertoAirHP.RatedCapCoolSens,
                         simpleWatertoAirHP.RatedAirVolFlowRate,
                         simpleWatertoAirHP.RatedWaterVolFlowRate);
-                } else if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating) {
-                    state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(
+                } else if (simpleWatertoAirHP.coilType == HVAC::CoilType::HeatingWAHPSimple) {
+                    ReportCoilSelection::setCoilFinalSizes(
                         state,
-                        simpleWatertoAirHP.Name,
-                        format("COIL:{}:WATERTOAIRHEATPUMP:EQUATIONFIT", WatertoAirHPNamesUC[static_cast<int>(simpleWatertoAirHP.WAHPType)]),
+                        simpleWatertoAirHP.coilReportNum,
                         simpleWatertoAirHP.RatedCapHeat,
                         simpleWatertoAirHP.RatedCapHeat,
                         simpleWatertoAirHP.RatedAirVolFlowRate,
@@ -3692,7 +3701,7 @@ namespace WaterToAirHeatPumpSimple {
 
         return SHReff;
     }
-
+#ifdef OLD_API
     int GetCoilIndex(EnergyPlusData &state,
                      std::string const &CoilType, // must match coil types in this module
                      std::string const &CoilName, // must match coil names for the coil type
@@ -3768,7 +3777,7 @@ namespace WaterToAirHeatPumpSimple {
                     int companionHeatingCoil = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(WhichCoil).CompanionHeatingCoilNum;
                     if (companionHeatingCoil > 0) {
                         if (CoilCapacity == DataSizing::AutoSize &&
-                            state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(companionHeatingCoil).WAHPPlantType ==
+                            state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(companionHeatingCoil).coilPlantType ==
                                 DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
                             state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(companionHeatingCoil).RatedCapHeat == DataSizing::AutoSize &&
                             state.dataSize->DXCoolCap > 0) {
@@ -3921,7 +3930,8 @@ namespace WaterToAirHeatPumpSimple {
 
         return NodeNumber;
     }
-
+#endif // OLD_API
+  
     void SetSimpleWSHPData(EnergyPlusData &state,
                            int const SimpleWSHPNum,                         // Number of OA Controller
                            bool &ErrorsFound,                               // Set to true if certain errors found
@@ -3978,7 +3988,7 @@ namespace WaterToAirHeatPumpSimple {
         if (WhichCoil == 0) return;
 
         auto &wahp = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(WhichCoil);
-        if (wahp.WAHPType == WatertoAirHP::Cooling) {
+        if (wahp.coilType == HVAC::CoilType::CoolingWAHPSimple) {
             if (wahp.RatedEntAirWetbulbTemp != DataSizing::AutoSize && wahp.TotalCoolCapCurve != nullptr && wahp.CoolPowCurve != nullptr) {
                 Real64 RatedratioTWB = (wahp.RatedEntAirWetbulbTemp + Constant::Kelvin) / Tref;
                 Real64 RatedratioTS = (wahp.RatedEntWaterTemp + Constant::Kelvin) / Tref;
@@ -4015,7 +4025,8 @@ namespace WaterToAirHeatPumpSimple {
                 }
             }
 
-        } else if (wahp.WAHPType == WatertoAirHP::Heating) {
+
+        } else if (wahp.coilType == HVAC::CoilType::HeatingWAHPSimple) {
             if (wahp.RatedEntAirDrybulbTemp != DataSizing::AutoSize && wahp.HeatCapCurve != nullptr && wahp.HeatPowCurve != nullptr) {
                 Real64 RatedHeatratioTDB = (wahp.RatedEntAirDrybulbTemp + Constant::Kelvin) / Tref;
                 Real64 RatedHeatratioTS = (wahp.RatedEntWaterTemp + Constant::Kelvin) / Tref;
@@ -4037,6 +4048,70 @@ namespace WaterToAirHeatPumpSimple {
             }
         }
     }
+
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName)
+    {
+        // Obtains and Allocates WatertoAirHP related parameters from input file
+        if (state.dataWaterToAirHeatPumpSimple->GetCoilsInputFlag) { // First time subroutine has been entered
+            GetSimpleWatertoAirHPInput(state);
+            state.dataWaterToAirHeatPumpSimple->GetCoilsInputFlag = false;
+        }
+
+        return Util::FindItemInList(coilName, state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP);
+    }
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum) 
+    {
+        // FUNCTION INFORMATION:
+        //       AUTHOR         Linda Lawrie
+        //       DATE WRITTEN   February 2006
+
+        // PURPOSE OF THIS FUNCTION:
+        // This function looks up the coil capacity for the given coil and returns it.  If
+        // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
+        // as negative.
+
+        assert(coilNum > 0 && coilNum <= state.dataWaterToAirHeatPumpSimple->NumWatertoAirHPs);
+        auto &coil = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(coilNum);
+
+        if (coil.coilType == HVAC::CoilType::HeatingWAHPSimple) {
+            return coil.RatedCapHeat;
+        } else {
+            Real64 CoilCapacity = coil.RatedCapCoolTotal;
+
+            if (coil.CompanionHeatingCoilNum > 0) {
+                auto &companionHeatingCoil = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(coil.CompanionHeatingCoilNum);
+                if (CoilCapacity == DataSizing::AutoSize &&
+                    companionHeatingCoil.coilPlantType == DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit &&
+                    companionHeatingCoil.RatedCapHeat == DataSizing::AutoSize &&
+                    state.dataSize->DXCoolCap > 0) {
+                    // Heating coil has not yet been sized, returning the temporary cooling capacity
+                    return state.dataSize->DXCoolCap;
+                }
+            }
+            return CoilCapacity;
+        }
+    }
+
+    Real64 GetCoilAirFlowRate(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataWaterToAirHeatPumpSimple->NumWatertoAirHPs);
+        return state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(coilNum).RatedAirVolFlowRate;
+    }
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataWaterToAirHeatPumpSimple->NumWatertoAirHPs);
+        return state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(coilNum).AirInletNodeNum;
+    }
+
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum)
+    {
+        assert(coilNum > 0 && coilNum <= state.dataWaterToAirHeatPumpSimple->NumWatertoAirHPs);
+        return state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(coilNum).AirOutletNodeNum;
+    }
+  
+  
 } // namespace WaterToAirHeatPumpSimple
 
 } // namespace EnergyPlus
diff --git a/src/EnergyPlus/WaterToAirHeatPumpSimple.hh b/src/EnergyPlus/WaterToAirHeatPumpSimple.hh
index f26bfacd814..f97944e59dd 100644
--- a/src/EnergyPlus/WaterToAirHeatPumpSimple.hh
+++ b/src/EnergyPlus/WaterToAirHeatPumpSimple.hh
@@ -69,20 +69,13 @@ namespace Curve {
 
 namespace WaterToAirHeatPumpSimple {
 
-    enum class WatertoAirHP
-    {
-        Invalid = -1,
-        Heating,
-        Cooling,
-        Num
-    };
-
     struct SimpleWatertoAirHPConditions
     {
         // Members
         std::string Name;                                                                     // Name of the Water to Air Heat pump
-        WatertoAirHP WAHPType = WatertoAirHP::Invalid;                                        // Type of WatertoAirHP ie. Heating or Cooling
-        DataPlant::PlantEquipmentType WAHPPlantType = DataPlant::PlantEquipmentType::Invalid; // type of component in plant
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;                                        // Type of WatertoAirHP ie. Heating or Cooling
+        DataPlant::PlantEquipmentType coilPlantType = DataPlant::PlantEquipmentType::Invalid; // type of component in plant
+      
         bool SimFlag = false;                                                                 // Heat Pump Simulation Flag
         Real64 AirVolFlowRate = 0.0;                                                          // Air Volumetric Flow Rate[m3/s]
         Real64 AirMassFlowRate = 0.0;                                                         // Air Mass Flow Rate[kg/s]
@@ -160,7 +153,9 @@ namespace WaterToAirHeatPumpSimple {
         Real64 MaxONOFFCyclesperHour = 0.0;      // Maximum cycling rate of heat pump [cycles/hr]
         Real64 LatentCapacityTimeConstant = 0.0; // Latent capcacity time constant [s]
         Real64 FanDelayTime = 0.0;               // Fan delay time, time delay for the HP's fan to
+      
         bool reportCoilFinalSizes = true;        // one time report of sizes to coil report
+        int coilReportNum = -1;
     };
 
     void SimWatertoAirHPSimple(EnergyPlusData &state,
@@ -175,6 +170,17 @@ namespace WaterToAirHeatPumpSimple {
                                Real64 const OnOffAirFlowRat = 1.0 // ratio of comp on to comp off air flow rate
     );
 
+    void SimWatertoAirHPSimple(EnergyPlusData &state,
+                               int const coilIndex,
+                               Real64 const SensLoad,     // Sensible demand load [W]
+                               Real64 const LatentLoad,   // Latent demand load [W]
+                               HVAC::FanOp const fanOp,   // Continuous fan OR cycling compressor
+                               HVAC::CompressorOp compressorOp,
+                               Real64 const PartLoadRatio,
+                               bool const FirstHVACIteration,
+                               Real64 const OnOffAirFlowRat = 1.0 // ratio of comp on to comp off air flow rate
+    );
+  
     // MODULE SUBROUTINES:
     //*************************************************************************
 
@@ -229,6 +235,7 @@ namespace WaterToAirHeatPumpSimple {
                             Real64 const EnteringWB  // Entering air wet-bulb temperature
     );
 
+#ifdef OLD_API  
     int GetCoilIndex(EnergyPlusData &state,
                      std::string const &CoilType, // must match coil types in this module
                      std::string const &CoilName, // must match coil names for the coil type
@@ -258,7 +265,17 @@ namespace WaterToAirHeatPumpSimple {
                           std::string const &CoilName, // must match coil names for the coil type
                           bool &ErrorsFound            // set to true if problem
     );
+#endif // OLD_API
+    int GetCoilIndex(EnergyPlusData &state, std::string const &coilName);
+
+    Real64 GetCoilCapacity(EnergyPlusData &state, int const coilNum);
+
+    Real64 GetCoilAirFlowRate(EnergyPlusData &state, int const coilNum);
+
+    int GetCoilAirInletNode(EnergyPlusData &state, int const coilNum);
 
+    int GetCoilAirOutletNode(EnergyPlusData &state, int const coilNum);
+  
     void SetSimpleWSHPData(EnergyPlusData &state,
                            int const SimpleWSHPNum,                             // Number of OA Controller
                            bool &ErrorsFound,                                   // Set to true if certain errors found
diff --git a/src/EnergyPlus/WindowAC.cc b/src/EnergyPlus/WindowAC.cc
index 985ef868bf9..0065cd411ed 100644
--- a/src/EnergyPlus/WindowAC.cc
+++ b/src/EnergyPlus/WindowAC.cc
@@ -108,8 +108,6 @@ namespace WindowAC {
 
     using namespace DataLoopNode;
     using namespace DataSizing;
-    using HVAC::CoilDX_CoolingHXAssisted;
-    using HVAC::CoilDX_CoolingSingleSpeed;
     using HVAC::SmallAirVolFlow;
     using HVAC::SmallLoad;
     using HVAC::SmallMassFlow;
@@ -218,8 +216,6 @@ namespace WindowAC {
         using BranchNodeConnections::SetUpCompSets;
 
         using NodeInputManager::GetOnlySingleNode;
-        auto &GetDXCoilOutletNode(DXCoils::GetCoilOutletNode);
-        auto &GetDXHXAsstdCoilOutletNode(HVACHXAssistedCoolingCoil::GetCoilOutletNode);
         using MixedAir::GetOAMixerIndex;
         using MixedAir::GetOAMixerNodeNumbers;
 
@@ -289,6 +285,8 @@ namespace WindowAC {
 
             WindACNum = WindACIndex;
 
+            auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+
             ErrorObjectHeader eoh{routineName, CurrentModuleObject, Alphas(1)};
 
             state.dataWindowAC->WindACNumericFields(WindACNum).FieldNames.allocate(NumNumbers);
@@ -296,20 +294,20 @@ namespace WindowAC {
             state.dataWindowAC->WindACNumericFields(WindACNum).FieldNames = cNumericFields;
             Util::IsNameEmpty(state, Alphas(1), CurrentModuleObject, ErrorsFound);
 
-            state.dataWindowAC->WindAC(WindACNum).Name = Alphas(1);
-            state.dataWindowAC->WindAC(WindACNum).UnitType = state.dataWindowAC->WindowAC_UnitType; // 'ZoneHVAC:WindowAirConditioner'
+            windAC.Name = Alphas(1);
+            windAC.UnitType = state.dataWindowAC->WindowAC_UnitType; // 'ZoneHVAC:WindowAirConditioner'
 
             if (lAlphaBlanks(2)) {
-                state.dataWindowAC->WindAC(WindACNum).availSched = Sched::GetScheduleAlwaysOn(state);
-            } else if ((state.dataWindowAC->WindAC(WindACNum).availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
+                windAC.availSched = Sched::GetScheduleAlwaysOn(state);
+            } else if ((windAC.availSched = Sched::GetSchedule(state, Alphas(2))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(2), Alphas(2));
                 ErrorsFound = true;
             }
 
-            state.dataWindowAC->WindAC(WindACNum).MaxAirVolFlow = Numbers(1);
-            state.dataWindowAC->WindAC(WindACNum).OutAirVolFlow = Numbers(2);
+            windAC.MaxAirVolFlow = Numbers(1);
+            windAC.OutAirVolFlow = Numbers(2);
 
-            state.dataWindowAC->WindAC(WindACNum).AirInNode = GetOnlySingleNode(state,
+            windAC.AirInNode = GetOnlySingleNode(state,
                                                                                 Alphas(3),
                                                                                 ErrorsFound,
                                                                                 DataLoopNode::ConnectionObjectType::ZoneHVACWindowAirConditioner,
@@ -319,7 +317,7 @@ namespace WindowAC {
                                                                                 NodeInputManager::CompFluidStream::Primary,
                                                                                 ObjectIsParent);
 
-            state.dataWindowAC->WindAC(WindACNum).AirOutNode = GetOnlySingleNode(state,
+            windAC.AirOutNode = GetOnlySingleNode(state,
                                                                                  Alphas(4),
                                                                                  ErrorsFound,
                                                                                  DataLoopNode::ConnectionObjectType::ZoneHVACWindowAirConditioner,
@@ -329,36 +327,34 @@ namespace WindowAC {
                                                                                  NodeInputManager::CompFluidStream::Primary,
                                                                                  ObjectIsParent);
 
-            state.dataWindowAC->WindAC(WindACNum).OAMixType = Alphas(5);
-            state.dataWindowAC->WindAC(WindACNum).OAMixName = Alphas(6);
+            windAC.OAMixType = Alphas(5);
+            windAC.OAMixName = Alphas(6);
             // Get outdoor air mixer node numbers
             bool errFlag = false;
             ValidateComponent(state,
-                              state.dataWindowAC->WindAC(WindACNum).OAMixType,
-                              state.dataWindowAC->WindAC(WindACNum).OAMixName,
+                              windAC.OAMixType,
+                              windAC.OAMixName,
                               errFlag,
                               CurrentModuleObject);
             if (errFlag) {
-                ShowContinueError(state, format("specified in {} = \"{}\".", CurrentModuleObject, state.dataWindowAC->WindAC(WindACNum).Name));
+                ShowContinueError(state, format("specified in {} = \"{}\".", CurrentModuleObject, windAC.Name));
                 ErrorsFound = true;
             } else {
                 // Get outdoor air mixer node numbers
-                OANodeNums = GetOAMixerNodeNumbers(state, state.dataWindowAC->WindAC(WindACNum).OAMixName, errFlag);
+                OANodeNums = GetOAMixerNodeNumbers(state, windAC.OAMixName, errFlag);
                 if (errFlag) {
                     ShowContinueError(state,
-                                      format("that was specified in {} = \"{}\"", CurrentModuleObject, state.dataWindowAC->WindAC(WindACNum).Name));
+                                      format("that was specified in {} = \"{}\"", CurrentModuleObject, windAC.Name));
                     ShowContinueError(state, "..OutdoorAir:Mixer is required. Enter an OutdoorAir:Mixer object with this name.");
                     ErrorsFound = true;
                 } else {
-                    state.dataWindowAC->WindAC(WindACNum).OutsideAirNode = OANodeNums(1);
-                    state.dataWindowAC->WindAC(WindACNum).AirReliefNode = OANodeNums(2);
-                    state.dataWindowAC->WindAC(WindACNum).ReturnAirNode = OANodeNums(3);
-                    state.dataWindowAC->WindAC(WindACNum).MixedAirNode = OANodeNums(4);
+                    windAC.OutsideAirNode = OANodeNums(1);
+                    windAC.AirReliefNode = OANodeNums(2);
+                    windAC.ReturnAirNode = OANodeNums(3);
+                    windAC.MixedAirNode = OANodeNums(4);
                 }
             }
 
-            auto &windAC = state.dataWindowAC->WindAC(WindACNum);
-
             windAC.FanName = Alphas(8);
 
             windAC.fanType = static_cast<HVAC::FanType>(getEnumValue(HVAC::fanTypeNamesUC, Alphas(7)));
@@ -385,74 +381,77 @@ namespace WindowAC {
                                                 CurrentModuleObject));
                         ShowContinueError(
                             state, format(" The fan flow rate must be >= to the {} in the {} object.", cNumericFields(1), CurrentModuleObject));
-                        ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, state.dataWindowAC->WindAC(WindACNum).Name));
+                        ShowContinueError(state, format(" Occurs in {} = {}", CurrentModuleObject, windAC.Name));
                         ErrorsFound = true;
                     }
                 }
                 windAC.fanAvailSched = fan->availSched;
             }
 
-            state.dataWindowAC->WindAC(WindACNum).DXCoilName = Alphas(10);
-
-            if (Util::SameString(Alphas(9), "Coil:Cooling:DX:SingleSpeed") ||
-                Util::SameString(Alphas(9), "CoilSystem:Cooling:DX:HeatExchangerAssisted") ||
-                Util::SameString(Alphas(9), "Coil:Cooling:DX:VariableSpeed")) {
-                state.dataWindowAC->WindAC(WindACNum).DXCoilType = Alphas(9);
-                CoilNodeErrFlag = false;
-                if (Util::SameString(Alphas(9), "Coil:Cooling:DX:SingleSpeed")) {
-                    state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num = CoilDX_CoolingSingleSpeed;
-                    state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum = GetDXCoilOutletNode(
-                        state, state.dataWindowAC->WindAC(WindACNum).DXCoilType, state.dataWindowAC->WindAC(WindACNum).DXCoilName, CoilNodeErrFlag);
-                } else if (Util::SameString(Alphas(9), "CoilSystem:Cooling:DX:HeatExchangerAssisted")) {
-                    state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num = CoilDX_CoolingHXAssisted;
-                    state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum = GetDXHXAsstdCoilOutletNode(
-                        state, state.dataWindowAC->WindAC(WindACNum).DXCoilType, state.dataWindowAC->WindAC(WindACNum).DXCoilName, CoilNodeErrFlag);
-                } else if (Util::SameString(Alphas(9), "Coil:Cooling:DX:VariableSpeed")) {
-                    state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num = HVAC::Coil_CoolingAirToAirVariableSpeed;
-                    state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum = VariableSpeedCoils::GetCoilOutletNodeVariableSpeed(
-                        state, state.dataWindowAC->WindAC(WindACNum).DXCoilType, state.dataWindowAC->WindAC(WindACNum).DXCoilName, CoilNodeErrFlag);
-                    state.dataWindowAC->WindAC(WindACNum).DXCoilNumOfSpeeds =
-                        VariableSpeedCoils::GetVSCoilNumOfSpeeds(state, state.dataWindowAC->WindAC(WindACNum).DXCoilName, ErrorsFound);
+            windAC.coilType = static_cast<HVAC::CoilType>(getEnumValue(HVAC::coilTypeNamesUC, Alphas(9)));
+            windAC.CoilName = Alphas(10);
+
+            if (windAC.coilType == HVAC::CoilType::CoolingDXSingleSpeed) { 
+                windAC.CoilNum = DXCoils::GetCoilIndex(state, windAC.CoilName);
+                if (windAC.CoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(10), windAC.CoilName);
+                    ErrorsFound = true;
+                } else {
+                    windAC.CoilAirOutletNode = DXCoils::GetCoilAirOutletNode(state, windAC.CoilNum);
                 }
-                if (CoilNodeErrFlag) {
-                    ShowContinueError(state,
-                                      format(" that was specified in {} = \"{}\".", CurrentModuleObject, state.dataWindowAC->WindAC(WindACNum).Name));
+
+            } else if (windAC.coilType == HVAC::CoilType::CoolingDXHXAssisted) { 
+                windAC.CoilNum = HXAssistCoil::GetCoilIndex(state, windAC.CoilName);
+                if (windAC.CoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(10), windAC.CoilName);
                     ErrorsFound = true;
+                } else {
+                  windAC.CoilAirOutletNode = HXAssistCoil::GetCoilAirOutletNode(state, windAC.CoilNum);
                 }
+
+            } else if (windAC.coilType == HVAC::CoilType::CoolingDXVariableSpeed) { 
+                windAC.CoilNum = VariableSpeedCoils::GetCoilIndex(state, windAC.CoilName);
+                if (windAC.CoilNum == 0) {
+                    ShowSevereItemNotFound(state, eoh, cAlphaFields(10), windAC.CoilName);
+                    ErrorsFound = true;
+                } else {
+                    windAC.CoilAirOutletNode = VariableSpeedCoils::GetCoilAirOutletNode(state, windAC.CoilNum);
+                    windAC.CoilNumOfSpeeds = VariableSpeedCoils::GetCoilNumOfSpeeds(state, windAC.CoilNum);
+                }
+
             } else {
-                ShowWarningError(state, format("Invalid {} = {}", cAlphaFields(9), Alphas(9)));
-                ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, state.dataWindowAC->WindAC(WindACNum).Name));
+                ShowSevereInvalidKey(state, eoh, cAlphaFields(9), Alphas(9));
                 ErrorsFound = true;
             }
 
             if (lAlphaBlanks(11)) {
-                state.dataWindowAC->WindAC(WindACNum).fanOp = HVAC::FanOp::Cycling;
-            } else if ((state.dataWindowAC->WindAC(WindACNum).fanOpModeSched = Sched::GetSchedule(state, Alphas(11))) == nullptr) {
+                windAC.fanOp = HVAC::FanOp::Cycling;
+            } else if ((windAC.fanOpModeSched = Sched::GetSchedule(state, Alphas(11))) == nullptr) {
                 ShowSevereItemNotFound(state, eoh, cAlphaFields(11), Alphas(11));
                 ErrorsFound = true;
             }
 
-            state.dataWindowAC->WindAC(WindACNum).fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(12)));
-            assert(state.dataWindowAC->WindAC(WindACNum).fanPlace != HVAC::FanPlace::Invalid);
+            windAC.fanPlace = static_cast<HVAC::FanPlace>(getEnumValue(HVAC::fanPlaceNamesUC, Alphas(12)));
+            assert(windAC.fanPlace != HVAC::FanPlace::Invalid);
 
-            state.dataWindowAC->WindAC(WindACNum).ConvergenceTol = Numbers(3);
+            windAC.ConvergenceTol = Numbers(3);
 
             if (!lAlphaBlanks(13)) {
-                state.dataWindowAC->WindAC(WindACNum).AvailManagerListName = Alphas(13);
+                windAC.AvailManagerListName = Alphas(13);
             }
 
-            state.dataWindowAC->WindAC(WindACNum).HVACSizingIndex = 0;
+            windAC.HVACSizingIndex = 0;
             if (!lAlphaBlanks(14)) {
-                state.dataWindowAC->WindAC(WindACNum).HVACSizingIndex = Util::FindItemInList(Alphas(14), state.dataSize->ZoneHVACSizing);
-                if (state.dataWindowAC->WindAC(WindACNum).HVACSizingIndex == 0) {
+                windAC.HVACSizingIndex = Util::FindItemInList(Alphas(14), state.dataSize->ZoneHVACSizing);
+                if (windAC.HVACSizingIndex == 0) {
                     ShowSevereError(state, format("{} = {} not found.", cAlphaFields(14), Alphas(14)));
-                    ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, state.dataWindowAC->WindAC(WindACNum).Name));
+                    ShowContinueError(state, format("Occurs in {} = {}", CurrentModuleObject, windAC.Name));
                     ErrorsFound = true;
                 }
             }
 
             // Add fan to component sets array
-            if (state.dataWindowAC->WindAC(WindACNum).fanPlace == HVAC::FanPlace::BlowThru) {
+            if (windAC.fanPlace == HVAC::FanPlace::BlowThru) {
 
                 // Window AC air inlet node must be the same as a zone exhaust node and the OA Mixer return node
                 // check that Window AC air inlet node is the same as a zone exhaust node.
@@ -460,7 +459,7 @@ namespace WindowAC {
                 for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                     if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                     for (NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumExhaustNodes; ++NodeNum) {
-                        if (state.dataWindowAC->WindAC(WindACNum).AirInNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).ExhaustNode(NodeNum)) {
+                        if (windAC.AirInNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).ExhaustNode(NodeNum)) {
                             ZoneNodeNotFound = false;
                             break;
                         }
@@ -470,11 +469,11 @@ namespace WindowAC {
                     ShowSevereError(state,
                                     format("{} = \"{}\". Window AC air inlet node name must be the same as a zone exhaust node name.",
                                            CurrentModuleObject,
-                                           state.dataWindowAC->WindAC(WindACNum).Name));
+                                           windAC.Name));
                     ShowContinueError(state, "..Zone exhaust node name is specified in ZoneHVAC:EquipmentConnections object.");
                     ShowContinueError(
                         state,
-                        format("..Window AC air inlet node name = {}", state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).AirInNode)));
+                        format("..Window AC air inlet node name = {}", state.dataLoopNodes->NodeID(windAC.AirInNode)));
                     ErrorsFound = true;
                 }
                 // check that Window AC air outlet node is a zone inlet node.
@@ -482,8 +481,8 @@ namespace WindowAC {
                 for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                     if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                     for (NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++NodeNum) {
-                        if (state.dataWindowAC->WindAC(WindACNum).AirOutNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(NodeNum)) {
-                            state.dataWindowAC->WindAC(WindACNum).ZonePtr = CtrlZone;
+                        if (windAC.AirOutNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(NodeNum)) {
+                            windAC.ZonePtr = CtrlZone;
                             ZoneNodeNotFound = false;
                             break;
                         }
@@ -493,24 +492,24 @@ namespace WindowAC {
                     ShowSevereError(state,
                                     format("{} = \"{}\". Window AC air outlet node name must be the same as a zone inlet node name.",
                                            CurrentModuleObject,
-                                           state.dataWindowAC->WindAC(WindACNum).Name));
+                                           windAC.Name));
                     ShowContinueError(state, "..Zone inlet node name is specified in ZoneHVAC:EquipmentConnections object.");
                     ShowContinueError(state,
                                       format("..Window AC air outlet node name = {}",
-                                             state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).AirOutNode)));
+                                             state.dataLoopNodes->NodeID(windAC.AirOutNode)));
                     ErrorsFound = true;
                 }
-                CompSetFanInlet = state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).MixedAirNode);
+                CompSetFanInlet = state.dataLoopNodes->NodeID(windAC.MixedAirNode);
                 CompSetFanOutlet = "UNDEFINED";
                 CompSetCoolInlet = "UNDEFINED";
-                CompSetCoolOutlet = state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).AirOutNode);
+                CompSetCoolOutlet = state.dataLoopNodes->NodeID(windAC.AirOutNode);
             } else { // draw through fan from IF (WindAC(WindACNum)%FanPlace == BlowThru) THEN
                 // check that Window AC air inlet node is the same as a zone exhaust node.
                 ZoneNodeNotFound = true;
                 for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                     if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                     for (NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumExhaustNodes; ++NodeNum) {
-                        if (state.dataWindowAC->WindAC(WindACNum).AirInNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).ExhaustNode(NodeNum)) {
+                        if (windAC.AirInNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).ExhaustNode(NodeNum)) {
                             ZoneNodeNotFound = false;
                             break;
                         }
@@ -520,11 +519,11 @@ namespace WindowAC {
                     ShowSevereError(state,
                                     format("{} = \"{}\". Window AC air inlet node name must be the same as a zone exhaust node name.",
                                            CurrentModuleObject,
-                                           state.dataWindowAC->WindAC(WindACNum).Name));
+                                           windAC.Name));
                     ShowContinueError(state, "..Zone exhaust node name is specified in ZoneHVAC:EquipmentConnections object.");
                     ShowContinueError(
                         state,
-                        format("..Window AC inlet node name = {}", state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).AirInNode)));
+                        format("..Window AC inlet node name = {}", state.dataLoopNodes->NodeID(windAC.AirInNode)));
                     ErrorsFound = true;
                 }
                 // check that Window AC air outlet node is the same as a zone inlet node.
@@ -532,8 +531,8 @@ namespace WindowAC {
                 for (CtrlZone = 1; CtrlZone <= state.dataGlobal->NumOfZones; ++CtrlZone) {
                     if (!state.dataZoneEquip->ZoneEquipConfig(CtrlZone).IsControlled) continue;
                     for (NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(CtrlZone).NumInletNodes; ++NodeNum) {
-                        if (state.dataWindowAC->WindAC(WindACNum).AirOutNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(NodeNum)) {
-                            state.dataWindowAC->WindAC(WindACNum).ZonePtr = CtrlZone;
+                        if (windAC.AirOutNode == state.dataZoneEquip->ZoneEquipConfig(CtrlZone).InletNode(NodeNum)) {
+                            windAC.ZonePtr = CtrlZone;
                             ZoneNodeNotFound = false;
                             break;
                         }
@@ -543,44 +542,44 @@ namespace WindowAC {
                     ShowSevereError(state,
                                     format("{} = \"{}\". Window AC air outlet node name must be the same as a zone inlet node name.",
                                            CurrentModuleObject,
-                                           state.dataWindowAC->WindAC(WindACNum).Name));
+                                           windAC.Name));
                     ShowContinueError(state, "..Zone inlet node name is specified in ZoneHVAC:EquipmentConnections object.");
                     ShowContinueError(
                         state,
-                        format("..Window AC outlet node name = {}", state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).AirOutNode)));
+                        format("..Window AC outlet node name = {}", state.dataLoopNodes->NodeID(windAC.AirOutNode)));
                     ErrorsFound = true;
                 }
-                CompSetFanInlet = state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum);
-                CompSetFanOutlet = state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).AirOutNode);
-                CompSetCoolInlet = state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).MixedAirNode);
-                CompSetCoolOutlet = state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum);
+                CompSetFanInlet = state.dataLoopNodes->NodeID(windAC.CoilAirOutletNode);
+                CompSetFanOutlet = state.dataLoopNodes->NodeID(windAC.AirOutNode);
+                CompSetCoolInlet = state.dataLoopNodes->NodeID(windAC.MixedAirNode);
+                CompSetCoolOutlet = state.dataLoopNodes->NodeID(windAC.CoilAirOutletNode);
             }
             // Add fan to component sets array
             SetUpCompSets(state,
-                          state.dataWindowAC->cWindowAC_UnitTypes(state.dataWindowAC->WindAC(WindACNum).UnitType),
-                          state.dataWindowAC->WindAC(WindACNum).Name,
-                          HVAC::fanTypeNames[(int)state.dataWindowAC->WindAC(WindACNum).fanType],
-                          state.dataWindowAC->WindAC(WindACNum).FanName,
+                          state.dataWindowAC->cWindowAC_UnitTypes(windAC.UnitType),
+                          windAC.Name,
+                          HVAC::fanTypeNames[(int)windAC.fanType],
+                          windAC.FanName,
                           CompSetFanInlet,
                           CompSetFanOutlet);
 
             // Add cooling coil to component sets array
             SetUpCompSets(state,
-                          state.dataWindowAC->cWindowAC_UnitTypes(state.dataWindowAC->WindAC(WindACNum).UnitType),
-                          state.dataWindowAC->WindAC(WindACNum).Name,
-                          state.dataWindowAC->WindAC(WindACNum).DXCoilType,
-                          state.dataWindowAC->WindAC(WindACNum).DXCoilName,
+                          state.dataWindowAC->cWindowAC_UnitTypes(windAC.UnitType),
+                          windAC.Name,
+                          HVAC::coilTypeNames[(int)windAC.coilType],
+                          windAC.CoilName,
                           CompSetCoolInlet,
                           CompSetCoolOutlet);
 
             // Set up component set for OA mixer - use OA node and Mixed air node
             SetUpCompSets(state,
-                          state.dataWindowAC->cWindowAC_UnitTypes(state.dataWindowAC->WindAC(WindACNum).UnitType),
-                          state.dataWindowAC->WindAC(WindACNum).Name,
-                          state.dataWindowAC->WindAC(WindACNum).OAMixType,
-                          state.dataWindowAC->WindAC(WindACNum).OAMixName,
-                          state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).OutsideAirNode),
-                          state.dataLoopNodes->NodeID(state.dataWindowAC->WindAC(WindACNum).MixedAirNode));
+                          state.dataWindowAC->cWindowAC_UnitTypes(windAC.UnitType),
+                          windAC.Name,
+                          windAC.OAMixType,
+                          windAC.OAMixName,
+                          state.dataLoopNodes->NodeID(windAC.OutsideAirNode),
+                          state.dataLoopNodes->NodeID(windAC.MixedAirNode));
         }
 
         Alphas.deallocate();
@@ -596,101 +595,104 @@ namespace WindowAC {
         }
 
         for (WindACNum = 1; WindACNum <= state.dataWindowAC->NumWindAC; ++WindACNum) {
+            auto &windAC = state.dataWindowAC->WindAC(WindACNum);
             // Setup Report variables for the Fan Coils
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Total Cooling Rate",
                                 Constant::Units::W,
-                                state.dataWindowAC->WindAC(WindACNum).TotCoolEnergyRate,
+                                windAC.TotCoolEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Total Cooling Energy",
                                 Constant::Units::J,
-                                state.dataWindowAC->WindAC(WindACNum).TotCoolEnergy,
+                                windAC.TotCoolEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Sensible Cooling Rate",
                                 Constant::Units::W,
-                                state.dataWindowAC->WindAC(WindACNum).SensCoolEnergyRate,
+                                windAC.SensCoolEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Sensible Cooling Energy",
                                 Constant::Units::J,
-                                state.dataWindowAC->WindAC(WindACNum).SensCoolEnergy,
+                                windAC.SensCoolEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Latent Cooling Rate",
                                 Constant::Units::W,
-                                state.dataWindowAC->WindAC(WindACNum).LatCoolEnergyRate,
+                                windAC.LatCoolEnergyRate,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Latent Cooling Energy",
                                 Constant::Units::J,
-                                state.dataWindowAC->WindAC(WindACNum).LatCoolEnergy,
+                                windAC.LatCoolEnergy,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Electricity Rate",
                                 Constant::Units::W,
-                                state.dataWindowAC->WindAC(WindACNum).ElecPower,
+                                windAC.ElecPower,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Electricity Energy",
                                 Constant::Units::J,
-                                state.dataWindowAC->WindAC(WindACNum).ElecConsumption,
+                                windAC.ElecConsumption,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Sum,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Fan Part Load Ratio",
                                 Constant::Units::None,
-                                state.dataWindowAC->WindAC(WindACNum).FanPartLoadRatio,
+                                windAC.FanPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Compressor Part Load Ratio",
                                 Constant::Units::None,
-                                state.dataWindowAC->WindAC(WindACNum).CompPartLoadRatio,
+                                windAC.CompPartLoadRatio,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             SetupOutputVariable(state,
                                 "Zone Window Air Conditioner Fan Availability Status",
                                 Constant::Units::None,
-                                (int &)state.dataWindowAC->WindAC(WindACNum).availStatus,
+                                (int &)windAC.availStatus,
                                 OutputProcessor::TimeStepType::System,
                                 OutputProcessor::StoreType::Average,
-                                state.dataWindowAC->WindAC(WindACNum).Name);
+                                windAC.Name);
             if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
                 SetupEMSActuator(state,
                                  "Window Air Conditioner",
-                                 state.dataWindowAC->WindAC(WindACNum).Name,
+                                 windAC.Name,
                                  "Part Load Ratio",
                                  "[fraction]",
-                                 state.dataWindowAC->WindAC(WindACNum).EMSOverridePartLoadFrac,
-                                 state.dataWindowAC->WindAC(WindACNum).EMSValueForPartLoadFrac);
+                                 windAC.EMSOverridePartLoadFrac,
+                                 windAC.EMSValueForPartLoadFrac);
             }
         }
+
         for (WindACNum = 1; WindACNum <= state.dataWindowAC->NumWindAC; ++WindACNum) {
-            state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(state,
-                                                                                     state.dataWindowAC->WindAC(WindACNum).DXCoilName,
-                                                                                     state.dataWindowAC->WindAC(WindACNum).DXCoilType,
-                                                                                     state.dataWindowAC->WindAC(WindACNum).FanName,
-                                                                                     state.dataWindowAC->WindAC(WindACNum).fanType,
-                                                                                     state.dataWindowAC->WindAC(WindACNum).FanIndex);
+            auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+            ReportCoilSelection::setCoilSupplyFanInfo(state,
+                                                      windAC.CoilName,
+                                                      windAC.coilType,
+                                                      windAC.FanName,
+                                                      windAC.fanType,
+                                                      windAC.FanIndex);
         }
     }
 
@@ -725,14 +727,16 @@ namespace WindowAC {
             state.dataWindowAC->MyOneTimeFlag = false;
         }
 
+        auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+        
         if (allocated(state.dataAvail->ZoneComp)) {
             auto &availMgr = state.dataAvail->ZoneComp(DataZoneEquipment::ZoneEquipType::WindowAirConditioner).ZoneCompAvailMgrs(WindACNum);
             if (state.dataWindowAC->MyZoneEqFlag(WindACNum)) { // initialize the name of each availability manager list and zone number
-                availMgr.AvailManagerListName = state.dataWindowAC->WindAC(WindACNum).AvailManagerListName;
+                availMgr.AvailManagerListName = windAC.AvailManagerListName;
                 availMgr.ZoneNum = ZoneNum;
                 state.dataWindowAC->MyZoneEqFlag(WindACNum) = false;
             }
-            state.dataWindowAC->WindAC(WindACNum).availStatus = availMgr.availStatus;
+            windAC.availStatus = availMgr.availStatus;
         }
 
         // need to check all Window AC units to see if they are on Zone Equipment List or issue warning
@@ -759,19 +763,19 @@ namespace WindowAC {
 
         // Do the Begin Environment initializations
         if (state.dataGlobal->BeginEnvrnFlag && state.dataWindowAC->MyEnvrnFlag(WindACNum)) {
-            int InNode = state.dataWindowAC->WindAC(WindACNum).AirInNode;
-            int OutNode = state.dataWindowAC->WindAC(WindACNum).AirOutNode;
-            int OutsideAirNode = state.dataWindowAC->WindAC(WindACNum).OutsideAirNode;
+            int InNode = windAC.AirInNode;
+            int OutNode = windAC.AirOutNode;
+            int OutsideAirNode = windAC.OutsideAirNode;
             Real64 RhoAir = state.dataEnvrn->StdRhoAir;
             // set the mass flow rates from the input volume flow rates
-            state.dataWindowAC->WindAC(WindACNum).MaxAirMassFlow = RhoAir * state.dataWindowAC->WindAC(WindACNum).MaxAirVolFlow;
-            state.dataWindowAC->WindAC(WindACNum).OutAirMassFlow = RhoAir * state.dataWindowAC->WindAC(WindACNum).OutAirVolFlow;
+            windAC.MaxAirMassFlow = RhoAir * windAC.MaxAirVolFlow;
+            windAC.OutAirMassFlow = RhoAir * windAC.OutAirVolFlow;
             // set the node max and min mass flow rates
-            state.dataLoopNodes->Node(OutsideAirNode).MassFlowRateMax = state.dataWindowAC->WindAC(WindACNum).OutAirMassFlow;
+            state.dataLoopNodes->Node(OutsideAirNode).MassFlowRateMax = windAC.OutAirMassFlow;
             state.dataLoopNodes->Node(OutsideAirNode).MassFlowRateMin = 0.0;
-            state.dataLoopNodes->Node(OutNode).MassFlowRateMax = state.dataWindowAC->WindAC(WindACNum).MaxAirMassFlow;
+            state.dataLoopNodes->Node(OutNode).MassFlowRateMax = windAC.MaxAirMassFlow;
             state.dataLoopNodes->Node(OutNode).MassFlowRateMin = 0.0;
-            state.dataLoopNodes->Node(InNode).MassFlowRateMax = state.dataWindowAC->WindAC(WindACNum).MaxAirMassFlow;
+            state.dataLoopNodes->Node(InNode).MassFlowRateMax = windAC.MaxAirMassFlow;
             state.dataLoopNodes->Node(InNode).MassFlowRateMin = 0.0;
             state.dataWindowAC->MyEnvrnFlag(WindACNum) = false;
         } // end one time inits
@@ -780,23 +784,23 @@ namespace WindowAC {
             state.dataWindowAC->MyEnvrnFlag(WindACNum) = true;
         }
 
-        if (state.dataWindowAC->WindAC(WindACNum).fanOpModeSched != nullptr) {
-            if (state.dataWindowAC->WindAC(WindACNum).fanOpModeSched->getCurrentVal() == 0.0) {
-                state.dataWindowAC->WindAC(WindACNum).fanOp = HVAC::FanOp::Cycling;
+        if (windAC.fanOpModeSched != nullptr) {
+            if (windAC.fanOpModeSched->getCurrentVal() == 0.0) {
+                windAC.fanOp = HVAC::FanOp::Cycling;
             } else {
-                state.dataWindowAC->WindAC(WindACNum).fanOp = HVAC::FanOp::Continuous;
+                windAC.fanOp = HVAC::FanOp::Continuous;
             }
         }
 
         // These initializations are done every iteration
-        int InletNode = state.dataWindowAC->WindAC(WindACNum).AirInNode;
-        int OutsideAirNode = state.dataWindowAC->WindAC(WindACNum).OutsideAirNode;
-        int AirRelNode = state.dataWindowAC->WindAC(WindACNum).AirReliefNode;
+        int InletNode = windAC.AirInNode;
+        int OutsideAirNode = windAC.OutsideAirNode;
+        int AirRelNode = windAC.AirReliefNode;
         // Set the inlet node mass flow rate
-        if (state.dataWindowAC->WindAC(WindACNum).availSched->getCurrentVal() <= 0.0 ||
-            (state.dataWindowAC->WindAC(WindACNum).fanAvailSched->getCurrentVal() <= 0.0 && !state.dataHVACGlobal->TurnFansOn) ||
+        if (windAC.availSched->getCurrentVal() <= 0.0 ||
+            (windAC.fanAvailSched->getCurrentVal() <= 0.0 && !state.dataHVACGlobal->TurnFansOn) ||
             state.dataHVACGlobal->TurnFansOff) {
-            state.dataWindowAC->WindAC(WindACNum).PartLoadFrac = 0.0;
+            windAC.PartLoadFrac = 0.0;
             state.dataLoopNodes->Node(InletNode).MassFlowRate = 0.0;
             state.dataLoopNodes->Node(InletNode).MassFlowRateMaxAvail = 0.0;
             state.dataLoopNodes->Node(InletNode).MassFlowRateMinAvail = 0.0;
@@ -807,33 +811,33 @@ namespace WindowAC {
             state.dataLoopNodes->Node(AirRelNode).MassFlowRateMaxAvail = 0.0;
             state.dataLoopNodes->Node(AirRelNode).MassFlowRateMinAvail = 0.0;
         } else {
-            state.dataWindowAC->WindAC(WindACNum).PartLoadFrac = 1.0;
-            state.dataLoopNodes->Node(InletNode).MassFlowRate = state.dataWindowAC->WindAC(WindACNum).MaxAirMassFlow;
+            windAC.PartLoadFrac = 1.0;
+            state.dataLoopNodes->Node(InletNode).MassFlowRate = windAC.MaxAirMassFlow;
             state.dataLoopNodes->Node(InletNode).MassFlowRateMaxAvail = state.dataLoopNodes->Node(InletNode).MassFlowRate;
             state.dataLoopNodes->Node(InletNode).MassFlowRateMinAvail = state.dataLoopNodes->Node(InletNode).MassFlowRate;
-            state.dataLoopNodes->Node(OutsideAirNode).MassFlowRate = state.dataWindowAC->WindAC(WindACNum).OutAirMassFlow;
-            state.dataLoopNodes->Node(OutsideAirNode).MassFlowRateMaxAvail = state.dataWindowAC->WindAC(WindACNum).OutAirMassFlow;
+            state.dataLoopNodes->Node(OutsideAirNode).MassFlowRate = windAC.OutAirMassFlow;
+            state.dataLoopNodes->Node(OutsideAirNode).MassFlowRateMaxAvail = windAC.OutAirMassFlow;
             state.dataLoopNodes->Node(OutsideAirNode).MassFlowRateMinAvail = 0.0;
-            state.dataLoopNodes->Node(AirRelNode).MassFlowRate = state.dataWindowAC->WindAC(WindACNum).OutAirMassFlow;
-            state.dataLoopNodes->Node(AirRelNode).MassFlowRateMaxAvail = state.dataWindowAC->WindAC(WindACNum).OutAirMassFlow;
+            state.dataLoopNodes->Node(AirRelNode).MassFlowRate = windAC.OutAirMassFlow;
+            state.dataLoopNodes->Node(AirRelNode).MassFlowRateMaxAvail = windAC.OutAirMassFlow;
             state.dataLoopNodes->Node(AirRelNode).MassFlowRateMinAvail = 0.0;
         }
 
         // Original thermostat control logic (works only for cycling fan systems)
         if (QZnReq < (-1.0 * HVAC::SmallLoad) && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum) &&
-            state.dataWindowAC->WindAC(WindACNum).PartLoadFrac > 0.0) {
+            windAC.PartLoadFrac > 0.0) {
             state.dataWindowAC->CoolingLoad = true;
         } else {
             state.dataWindowAC->CoolingLoad = false;
         }
 
         // Constant fan systems are tested for ventilation load to determine if load to be met changes.
-        if (state.dataWindowAC->WindAC(WindACNum).fanOp == HVAC::FanOp::Continuous && state.dataWindowAC->WindAC(WindACNum).PartLoadFrac > 0.0 &&
-            (state.dataWindowAC->WindAC(WindACNum).fanAvailSched->getCurrentVal() > 0.0 || state.dataHVACGlobal->TurnFansOn) &&
+        if (windAC.fanOp == HVAC::FanOp::Continuous && windAC.PartLoadFrac > 0.0 &&
+            (windAC.fanAvailSched->getCurrentVal() > 0.0 || state.dataHVACGlobal->TurnFansOn) &&
             !state.dataHVACGlobal->TurnFansOff) {
 
             Real64 NoCompOutput; // sensible load delivered with compressor off (W)
-            CalcWindowACOutput(state, WindACNum, FirstHVACIteration, state.dataWindowAC->WindAC(WindACNum).fanOp, 0.0, false, NoCompOutput);
+            CalcWindowACOutput(state, WindACNum, FirstHVACIteration, windAC.fanOp, 0.0, false, NoCompOutput);
 
             Real64 QToCoolSetPt = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputReqToCoolSP;
 
@@ -871,7 +875,7 @@ namespace WindowAC {
         static constexpr std::string_view RoutineName("SizeWindowAC: "); // include trailing blank space
 
         // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
-        auto &windowAC = state.dataWindowAC->WindAC(WindACNum);
+        auto &windAC = state.dataWindowAC->WindAC(WindACNum);
 
         Real64 MaxAirVolFlowDes = 0.0;                                // Autosized maximum air flow for reporting
         Real64 MaxAirVolFlowUser = 0.0;                               // Hardsized maximum air flow for reporting
@@ -879,7 +883,7 @@ namespace WindowAC {
         Real64 OutAirVolFlowUser = 0.0;                               // Hardsized outdoor ari flow for reporting
         bool IsAutoSize = false;                                      // Indicator to autosize
         std::string const CompType = "ZoneHVAC:WindowAirConditioner"; // component name
-        std::string const CompName = windowAC.Name;                   // component type
+        std::string const CompName = windAC.Name;                   // component type
         Real64 TempSize = AutoSize;                                   // autosized value of coil input field
         int FieldNum = 2;                                             // IDD numeric field number where input field description is found
         bool PrintFlag = false;                                       // TRUE when sizing information is reported in the eio file
@@ -892,17 +896,18 @@ namespace WindowAC {
         state.dataSize->ZoneHeatingOnlyFan = false;
         state.dataSize->ZoneCoolingOnlyFan = true;
         state.dataSize->DataScalableCapSizingON = false;
-        state.dataSize->DataZoneNumber = windowAC.ZonePtr;
-        state.dataSize->DataFanType = windowAC.fanType;
-        state.dataSize->DataFanIndex = windowAC.FanIndex;
-        state.dataSize->DataFanPlacement = windowAC.fanPlace;
+
+        state.dataSize->DataZoneNumber = windAC.ZonePtr;
+        state.dataSize->DataFanType = windAC.fanType;
+        state.dataSize->DataFanIndex = windAC.FanIndex;
+        state.dataSize->DataFanPlacement = windAC.fanPlace;
 
         if (state.dataSize->CurZoneEqNum > 0) {
             auto &zoneEqSizing = state.dataSize->ZoneEqSizing(state.dataSize->CurZoneEqNum);
 
-            if (windowAC.HVACSizingIndex > 0) {
+            if (windAC.HVACSizingIndex > 0) {
                 // N1 , \field Maximum Supply Air Flow Rate
-                auto const &zoneHVACSizing = state.dataSize->ZoneHVACSizing(windowAC.HVACSizingIndex);
+                auto const &zoneHVACSizing = state.dataSize->ZoneHVACSizing(windAC.HVACSizingIndex);
 
                 int SizingMethod = HVAC::CoolingAirflowSizing;
                 PrintFlag = true;
@@ -938,7 +943,7 @@ namespace WindowAC {
                     sizingCoolingAirFlow.overrideSizingString(stringOverride);
                     // sizingCoolingAirFlow.setHVACSizingIndexData(windowAC.HVACSizingIndex);
                     sizingCoolingAirFlow.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
-                    windowAC.MaxAirVolFlow = sizingCoolingAirFlow.size(state, TempSize, errorsFound);
+                    windAC.MaxAirVolFlow = sizingCoolingAirFlow.size(state, TempSize, errorsFound);
 
                 } else if (SAFMethod == FlowPerCoolingCapacity) {
                     SizingMethod = HVAC::CoolingCapacitySizing;
@@ -966,7 +971,7 @@ namespace WindowAC {
                     sizingCoolingAirFlow.overrideSizingString(stringOverride);
                     // sizingCoolingAirFlow.setHVACSizingIndexData(windowAC.HVACSizingIndex);
                     sizingCoolingAirFlow.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
-                    windowAC.MaxAirVolFlow = sizingCoolingAirFlow.size(state, TempSize, errorsFound);
+                    windAC.MaxAirVolFlow = sizingCoolingAirFlow.size(state, TempSize, errorsFound);
                 }
                 // DataScalableSizingON = false;
 
@@ -999,36 +1004,37 @@ namespace WindowAC {
                 int FieldNum = 1;
                 PrintFlag = true;
                 std::string stringOverride = state.dataWindowAC->WindACNumericFields(WindACNum).FieldNames(FieldNum) + " [m3/s]";
-                TempSize = windowAC.MaxAirVolFlow;
+                TempSize = windAC.MaxAirVolFlow;
                 bool errorsFound = false;
                 SystemAirFlowSizer sizerSystemAirFlow;
                 sizerSystemAirFlow.overrideSizingString(stringOverride);
                 // sizerSystemAirFlow.setHVACSizingIndexData(windowAC.HVACSizingIndex);
                 sizerSystemAirFlow.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
-                windowAC.MaxAirVolFlow = sizerSystemAirFlow.size(state, TempSize, errorsFound);
+                windAC.MaxAirVolFlow = sizerSystemAirFlow.size(state, TempSize, errorsFound);
             }
 
-            if (windowAC.OutAirVolFlow == AutoSize) {
+            if (windAC.OutAirVolFlow == AutoSize) {
 
-                CheckZoneSizing(state, state.dataWindowAC->cWindowAC_UnitTypes(windowAC.UnitType), windowAC.Name);
-                windowAC.OutAirVolFlow = min(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).MinOA, windowAC.MaxAirVolFlow);
-                if (windowAC.OutAirVolFlow < SmallAirVolFlow) {
-                    windowAC.OutAirVolFlow = 0.0;
+                CheckZoneSizing(state, state.dataWindowAC->cWindowAC_UnitTypes(windAC.UnitType), windAC.Name);
+                windAC.OutAirVolFlow = min(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).MinOA, windAC.MaxAirVolFlow);
+                if (windAC.OutAirVolFlow < SmallAirVolFlow) {
+                    windAC.OutAirVolFlow = 0.0;
                 }
                 BaseSizer::reportSizerOutput(state,
-                                             state.dataWindowAC->cWindowAC_UnitTypes(windowAC.UnitType),
-                                             windowAC.Name,
+                                             state.dataWindowAC->cWindowAC_UnitTypes(windAC.UnitType),
+                                             windAC.Name,
                                              "Maximum Outdoor Air Flow Rate [m3/s]",
-                                             windowAC.OutAirVolFlow);
+                                             windAC.OutAirVolFlow);
+                
             }
 
-            zoneEqSizing.OAVolFlow = windowAC.OutAirVolFlow;
-            zoneEqSizing.AirVolFlow = windowAC.MaxAirVolFlow;
+            auto &ZoneEqSizing = state.dataSize->ZoneEqSizing(state.dataSize->CurZoneEqNum);
+            ZoneEqSizing.OAVolFlow = windAC.OutAirVolFlow;
+            ZoneEqSizing.AirVolFlow = windAC.MaxAirVolFlow;
             // Make the Fan be sized by this
             zoneEqSizing.CoolingAirFlow = true;
-            zoneEqSizing.CoolingAirVolFlow = windowAC.MaxAirVolFlow;
-        }
-
+            zoneEqSizing.CoolingAirVolFlow = windAC.MaxAirVolFlow;
+        }            
         state.dataSize->DataScalableCapSizingON = false;
     }
 
@@ -1058,28 +1064,30 @@ namespace WindowAC {
         bool HXUnitOn;       // Used to control HX heat recovery as needed
 
         // zero the DX coil electricity consumption
-
         state.dataHVACGlobal->DXElecCoolingPower = 0.0;
+
+        auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+        
         // initialize local variables
         bool UnitOn = true;
         bool CoilOn = true;
         Real64 QUnitOut = 0.0;     // Dry air sens. cooling provided by AC unit [watts]
         Real64 LatentOutput = 0.0; // Latent (moisture) add/removal rate, negative is dehumidification [kg/s]
-        int OutletNode = state.dataWindowAC->WindAC(WindACNum).AirOutNode;
-        int InletNode = state.dataWindowAC->WindAC(WindACNum).AirInNode;
+        int OutletNode = windAC.AirOutNode;
+        int InletNode = windAC.AirInNode;
         Real64 AirMassFlow = state.dataLoopNodes->Node(InletNode).MassFlowRate;
         Real64 Test = AirMassFlow;
         Real64 CpAir = PsyCpAirFnW(state.dataLoopNodes->Node(InletNode).HumRat); // inlet air specific heat [J/kg-C]
-        HVAC::FanOp fanOp = state.dataWindowAC->WindAC(WindACNum).fanOp;
+        HVAC::FanOp fanOp = windAC.fanOp;
 
         // set the on/off flags
-        if (state.dataWindowAC->WindAC(WindACNum).fanOp == HVAC::FanOp::Cycling) {
+        if (windAC.fanOp == HVAC::FanOp::Cycling) {
             // cycling unit: only runs if there is a load.
             if (!state.dataWindowAC->CoolingLoad || AirMassFlow < SmallMassFlow) {
                 UnitOn = false;
                 CoilOn = false;
             }
-        } else if (state.dataWindowAC->WindAC(WindACNum).fanOp == HVAC::FanOp::Continuous) {
+        } else if (windAC.fanOp == HVAC::FanOp::Continuous) {
             // continuous unit: fan runs if scheduled on; coil runs only if cooling load
             if (AirMassFlow < SmallMassFlow) {
                 UnitOn = false;
@@ -1099,7 +1107,7 @@ namespace WindowAC {
             HXUnitOn = false;
         }
 
-        state.dataWindowAC->WindAC(WindACNum).PartLoadFrac = PartLoadFrac;
+        windAC.PartLoadFrac = PartLoadFrac;
 
         CalcWindowACOutput(state, WindACNum, FirstHVACIteration, fanOp, PartLoadFrac, HXUnitOn, QUnitOut);
 
@@ -1122,24 +1130,24 @@ namespace WindowAC {
         Real64 QTotUnitOut = AirMassFlow * (state.dataLoopNodes->Node(OutletNode).Enthalpy - state.dataLoopNodes->Node(InletNode).Enthalpy);
 
         // report variables
-        state.dataWindowAC->WindAC(WindACNum).CompPartLoadRatio = state.dataWindowAC->WindAC(WindACNum).PartLoadFrac;
-        if (state.dataWindowAC->WindAC(WindACNum).fanOp == HVAC::FanOp::Cycling) {
-            state.dataWindowAC->WindAC(WindACNum).FanPartLoadRatio = state.dataWindowAC->WindAC(WindACNum).PartLoadFrac;
+        windAC.CompPartLoadRatio = windAC.PartLoadFrac;
+        if (windAC.fanOp == HVAC::FanOp::Cycling) {
+            windAC.FanPartLoadRatio = windAC.PartLoadFrac;
         } else {
             if (UnitOn) {
-                state.dataWindowAC->WindAC(WindACNum).FanPartLoadRatio = 1.0;
+                windAC.FanPartLoadRatio = 1.0;
             } else {
-                state.dataWindowAC->WindAC(WindACNum).FanPartLoadRatio = 0.0;
+                windAC.FanPartLoadRatio = 0.0;
             }
         }
-        state.dataWindowAC->WindAC(WindACNum).SensCoolEnergyRate = std::abs(min(0.0, SensCoolOut));
-        state.dataWindowAC->WindAC(WindACNum).TotCoolEnergyRate = std::abs(min(0.0, QTotUnitOut));
-        state.dataWindowAC->WindAC(WindACNum).SensCoolEnergyRate =
-            min(state.dataWindowAC->WindAC(WindACNum).SensCoolEnergyRate, state.dataWindowAC->WindAC(WindACNum).TotCoolEnergyRate);
-        state.dataWindowAC->WindAC(WindACNum).LatCoolEnergyRate =
-            state.dataWindowAC->WindAC(WindACNum).TotCoolEnergyRate - state.dataWindowAC->WindAC(WindACNum).SensCoolEnergyRate;
-        Real64 locFanElecPower = state.dataFans->fans(state.dataWindowAC->WindAC(WindACNum).FanIndex)->totalPower;
-        state.dataWindowAC->WindAC(WindACNum).ElecPower = locFanElecPower + state.dataHVACGlobal->DXElecCoolingPower;
+        windAC.SensCoolEnergyRate = std::abs(min(0.0, SensCoolOut));
+        windAC.TotCoolEnergyRate = std::abs(min(0.0, QTotUnitOut));
+        windAC.SensCoolEnergyRate =
+            min(windAC.SensCoolEnergyRate, windAC.TotCoolEnergyRate);
+        windAC.LatCoolEnergyRate =
+            windAC.TotCoolEnergyRate - windAC.SensCoolEnergyRate;
+        Real64 locFanElecPower = state.dataFans->fans(windAC.FanIndex)->totalPower;
+        windAC.ElecPower = locFanElecPower + state.dataHVACGlobal->DXElecCoolingPower;
 
         PowerMet = QUnitOut;
         LatOutputProvided = LatentOutput;
@@ -1157,14 +1165,16 @@ namespace WindowAC {
 
         Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
 
-        state.dataWindowAC->WindAC(WindACNum).SensCoolEnergy = state.dataWindowAC->WindAC(WindACNum).SensCoolEnergyRate * TimeStepSysSec;
-        state.dataWindowAC->WindAC(WindACNum).TotCoolEnergy = state.dataWindowAC->WindAC(WindACNum).TotCoolEnergyRate * TimeStepSysSec;
-        state.dataWindowAC->WindAC(WindACNum).LatCoolEnergy = state.dataWindowAC->WindAC(WindACNum).LatCoolEnergyRate * TimeStepSysSec;
-        state.dataWindowAC->WindAC(WindACNum).ElecConsumption = state.dataWindowAC->WindAC(WindACNum).ElecPower * TimeStepSysSec;
+        auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+        
+        windAC.SensCoolEnergy = windAC.SensCoolEnergyRate * TimeStepSysSec;
+        windAC.TotCoolEnergy = windAC.TotCoolEnergyRate * TimeStepSysSec;
+        windAC.LatCoolEnergy = windAC.LatCoolEnergyRate * TimeStepSysSec;
+        windAC.ElecConsumption = windAC.ElecPower * TimeStepSysSec;
 
-        if (state.dataWindowAC->WindAC(WindACNum).FirstPass) { // reset sizing flags so other zone equipment can size normally
+        if (windAC.FirstPass) { // reset sizing flags so other zone equipment can size normally
             if (!state.dataGlobal->SysSizingCalc) {
-                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, 0, state.dataWindowAC->WindAC(WindACNum).FirstPass);
+                DataSizing::resetHVACSizingGlobals(state, state.dataSize->CurZoneEqNum, 0, windAC.FirstPass);
             }
         }
     }
@@ -1190,10 +1200,12 @@ namespace WindowAC {
         // METHODOLOGY EMPLOYED:
         // Simulates the unit components sequentially in the air flow direction.
 
-        int OutletNode = state.dataWindowAC->WindAC(WindACNum).AirOutNode;
-        int InletNode = state.dataWindowAC->WindAC(WindACNum).AirInNode;
-        int OutsideAirNode = state.dataWindowAC->WindAC(WindACNum).OutsideAirNode;
-        int AirRelNode = state.dataWindowAC->WindAC(WindACNum).AirReliefNode;
+        auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+        
+        int OutletNode = windAC.AirOutNode;
+        int InletNode = windAC.AirInNode;
+        int OutsideAirNode = windAC.OutsideAirNode;
+        int AirRelNode = windAC.AirReliefNode;
         // for cycling fans, pretend we have VAV
         if (fanOp == HVAC::FanOp::Cycling) {
             state.dataLoopNodes->Node(InletNode).MassFlowRate = state.dataLoopNodes->Node(InletNode).MassFlowRateMax * PartLoadFrac;
@@ -1203,51 +1215,50 @@ namespace WindowAC {
             state.dataLoopNodes->Node(AirRelNode).MassFlowRate = state.dataLoopNodes->Node(OutsideAirNode).MassFlowRate;
         }
         Real64 AirMassFlow = state.dataLoopNodes->Node(InletNode).MassFlowRate;
-        MixedAir::SimOAMixer(state, state.dataWindowAC->WindAC(WindACNum).OAMixName, state.dataWindowAC->WindAC(WindACNum).OAMixIndex);
+        MixedAir::SimOAMixer(state, windAC.OAMixName, windAC.OAMixIndex);
 
         // if blow through, simulate fan then coil. For draw through, simulate coil then fan.
-        if (state.dataWindowAC->WindAC(WindACNum).fanPlace == HVAC::FanPlace::BlowThru) {
-            state.dataFans->fans(state.dataWindowAC->WindAC(WindACNum).FanIndex)->simulate(state, FirstHVACIteration, PartLoadFrac);
+        if (windAC.fanPlace == HVAC::FanPlace::BlowThru) {
+            state.dataFans->fans(windAC.FanIndex)->simulate(state, FirstHVACIteration, PartLoadFrac);
         }
 
-        if (state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num == CoilDX_CoolingHXAssisted) {
-            HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil(state,
-                                                                state.dataWindowAC->WindAC(WindACNum).DXCoilName,
-                                                                FirstHVACIteration,
-                                                                HVAC::CompressorOp::On,
-                                                                PartLoadFrac,
-                                                                state.dataWindowAC->WindAC(WindACNum).DXCoilIndex,
-                                                                state.dataWindowAC->WindAC(WindACNum).fanOp,
-                                                                HXUnitOn);
-        } else if (state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num == HVAC::Coil_CoolingAirToAirVariableSpeed) {
+        if (windAC.coilType == HVAC::CoilType::CoolingDXHXAssisted) {
+            HXAssistCoil::SimHXAssistedCoolingCoil(state,
+                                                   windAC.CoilNum,
+                                                   FirstHVACIteration,
+                                                   HVAC::CompressorOp::On,
+                                                   PartLoadFrac,
+                                                   windAC.fanOp,
+                                                   HXUnitOn);
+            
+        } else if (windAC.coilType == HVAC::CoilType::CoolingDXVariableSpeed) {
             Real64 QZnReq(-1.0);           // Zone load (W), input to variable-speed DX coil
             Real64 QLatReq(0.0);           // Zone latent load, input to variable-speed DX coil
             Real64 OnOffAirFlowRatio(1.0); // ratio of compressor on flow to average flow over time step
 
             VariableSpeedCoils::SimVariableSpeedCoils(state,
-                                                      state.dataWindowAC->WindAC(WindACNum).DXCoilName,
-                                                      state.dataWindowAC->WindAC(WindACNum).DXCoilIndex,
-                                                      state.dataWindowAC->WindAC(WindACNum).fanOp,
+                                                      windAC.CoilNum,
+                                                      windAC.fanOp,
                                                       HVAC::CompressorOp::On,
                                                       PartLoadFrac,
-                                                      state.dataWindowAC->WindAC(WindACNum).DXCoilNumOfSpeeds,
+                                                      windAC.CoilNumOfSpeeds,
                                                       1.0,
                                                       QZnReq,
                                                       QLatReq,
                                                       OnOffAirFlowRatio);
 
+
         } else {
             DXCoils::SimDXCoil(state,
-                               state.dataWindowAC->WindAC(WindACNum).DXCoilName,
+                               windAC.CoilNum,
                                HVAC::CompressorOp::On,
                                FirstHVACIteration,
-                               state.dataWindowAC->WindAC(WindACNum).DXCoilIndex,
-                               state.dataWindowAC->WindAC(WindACNum).fanOp,
+                               windAC.fanOp,
                                PartLoadFrac);
         }
 
-        if (state.dataWindowAC->WindAC(WindACNum).fanPlace == HVAC::FanPlace::DrawThru) {
-            state.dataFans->fans(state.dataWindowAC->WindAC(WindACNum).FanIndex)->simulate(state, FirstHVACIteration, PartLoadFrac);
+        if (windAC.fanPlace == HVAC::FanPlace::DrawThru) {
+            state.dataFans->fans(windAC.FanIndex)->simulate(state, FirstHVACIteration, PartLoadFrac);
         }
 
         Real64 MinHumRat = min(state.dataLoopNodes->Node(InletNode).HumRat, state.dataLoopNodes->Node(OutletNode).HumRat);
@@ -1283,10 +1294,12 @@ namespace WindowAC {
         Real64 NoCoolOutput; // output when no active cooling [W]
         Real64 ActualOutput; // output at current partloadfrac [W]
 
+        auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+        
         // DX Cooling HX assisted coils can cycle the heat exchanger, see if coil ON, HX OFF can meet humidity setpoint if one exists
-        if (state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num == CoilDX_CoolingHXAssisted) {
+        if (windAC.coilType == HVAC::CoilType::CoolingDXHXAssisted) {
             // Check for a setpoint at the HX outlet node, if it doesn't exist always run the HX
-            if (state.dataLoopNodes->Node(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum).HumRatMax == SensedNodeFlagValue) {
+            if (state.dataLoopNodes->Node(windAC.CoilAirOutletNode).HumRatMax == SensedNodeFlagValue) {
                 HXUnitOn = true;
             } else {
                 HXUnitOn = false;
@@ -1295,9 +1308,8 @@ namespace WindowAC {
             HXUnitOn = false;
         }
 
-        if (state.dataWindowAC->WindAC(WindACNum).EMSOverridePartLoadFrac) {
-
-            PartLoadFrac = state.dataWindowAC->WindAC(WindACNum).EMSValueForPartLoadFrac;
+        if (windAC.EMSOverridePartLoadFrac) {
+            PartLoadFrac = windAC.EMSValueForPartLoadFrac;
         }
 
         // Get result when DX coil is off
@@ -1320,15 +1332,15 @@ namespace WindowAC {
         }
 
         // If the QZnReq <= FullOutput the unit needs to run full out
-        if (QZnReq <= FullOutput && state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num != CoilDX_CoolingHXAssisted) {
+        if (QZnReq <= FullOutput && windAC.coilType != HVAC::CoilType::CoolingDXHXAssisted) {
             PartLoadFrac = 1.0;
             return;
         }
 
         // If the QZnReq <= FullOutput and a HXAssisted coil is used, check the node setpoint for a maximum humidity ratio set point
         // HumRatMax will be equal to -999 if no setpoint exists or some set point managers may still use 0 as a no moisture load indicator
-        if (QZnReq <= FullOutput && state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num == CoilDX_CoolingHXAssisted &&
-            state.dataLoopNodes->Node(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum).HumRatMax <= 0.0) {
+        if (QZnReq <= FullOutput && windAC.coilType == HVAC::CoilType::CoolingDXHXAssisted &&
+            state.dataLoopNodes->Node(windAC.CoilAirOutletNode).HumRatMax <= 0.0) {
             PartLoadFrac = 1.0;
             return;
         }
@@ -1338,7 +1350,7 @@ namespace WindowAC {
 
         PartLoadFrac = max(MinPLF, std::abs(QZnReq - NoCoolOutput) / std::abs(FullOutput - NoCoolOutput));
 
-        Real64 ErrorToler = state.dataWindowAC->WindAC(WindACNum).ConvergenceTol; // Error tolerance for convergence from input deck
+        Real64 ErrorToler = windAC.ConvergenceTol; // Error tolerance for convergence from input deck
         Real64 Error = 1.0;                                                       // initialize error value for comparison against tolerance
         int Iter = 0;                                                             // initialize iteration counter
         Real64 Relax = 1.0;
@@ -1356,24 +1368,24 @@ namespace WindowAC {
             }
         }
         if (Iter > MaxIter) {
-            if (state.dataWindowAC->WindAC(WindACNum).MaxIterIndex1 == 0) {
+            if (windAC.MaxIterIndex1 == 0) {
                 ShowWarningMessage(state,
                                    format("ZoneHVAC:WindowAirConditioner=\"{}\" -- Exceeded max iterations while adjusting compressor sensible "
                                           "runtime to meet the zone load within the cooling convergence tolerance.",
-                                          state.dataWindowAC->WindAC(WindACNum).Name));
+                                          windAC.Name));
                 ShowContinueErrorTimeStamp(state, format("Iterations={}", MaxIter));
             }
             ShowRecurringWarningErrorAtEnd(state,
-                                           "ZoneHVAC:WindowAirConditioner=\"" + state.dataWindowAC->WindAC(WindACNum).Name +
+                                           "ZoneHVAC:WindowAirConditioner=\"" + windAC.Name +
                                                "\"  -- Exceeded max iterations error (sensible runtime) continues...",
-                                           state.dataWindowAC->WindAC(WindACNum).MaxIterIndex1);
+                                           windAC.MaxIterIndex1);
         }
 
         // HX is off up until this point where the outlet air humidity ratio is tested to see if HX needs to be turned on
-        if (state.dataWindowAC->WindAC(WindACNum).DXCoilType_Num == CoilDX_CoolingHXAssisted &&
-            state.dataLoopNodes->Node(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum).HumRatMax <
-                state.dataLoopNodes->Node(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum).HumRat &&
-            state.dataLoopNodes->Node(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum).HumRatMax > 0.0) {
+        if (windAC.coilType == HVAC::CoilType::CoolingDXHXAssisted &&
+            state.dataLoopNodes->Node(windAC.CoilAirOutletNode).HumRatMax <
+                state.dataLoopNodes->Node(windAC.CoilAirOutletNode).HumRat &&
+            state.dataLoopNodes->Node(windAC.CoilAirOutletNode).HumRatMax > 0.0) {
 
             //   Run the HX to recovery energy and improve latent performance
             HXUnitOn = true;
@@ -1381,8 +1393,8 @@ namespace WindowAC {
             //   Get full load result
             CalcWindowACOutput(state, WindACNum, FirstHVACIteration, fanOp, 1.0, HXUnitOn, FullOutput);
 
-            if (state.dataLoopNodes->Node(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum).HumRatMax <
-                    state.dataLoopNodes->Node(state.dataWindowAC->WindAC(WindACNum).CoilOutletNodeNum).HumRat ||
+            if (state.dataLoopNodes->Node(windAC.CoilAirOutletNode).HumRatMax <
+                    state.dataLoopNodes->Node(windAC.CoilAirOutletNode).HumRat ||
                 QZnReq <= FullOutput) {
                 PartLoadFrac = 1.0;
                 return;
@@ -1405,17 +1417,17 @@ namespace WindowAC {
                 }
             }
             if (Iter > MaxIter) {
-                if (state.dataWindowAC->WindAC(WindACNum).MaxIterIndex2 == 0) {
+                if (windAC.MaxIterIndex2 == 0) {
                     ShowWarningMessage(state,
                                        format("ZoneHVAC:WindowAirConditioner=\"{}\" -- Exceeded max iterations while adjusting compressor latent "
                                               "runtime to meet the zone load within the cooling convergence tolerance.",
-                                              state.dataWindowAC->WindAC(WindACNum).Name));
+                                              windAC.Name));
                     ShowContinueErrorTimeStamp(state, format("Iterations={}", MaxIter));
                 }
                 ShowRecurringWarningErrorAtEnd(state,
-                                               "ZoneHVAC:WindowAirConditioner=\"" + state.dataWindowAC->WindAC(WindACNum).Name +
+                                               "ZoneHVAC:WindowAirConditioner=\"" + windAC.Name +
                                                    "\"  -- Exceeded max iterations error (latent runtime) continues...",
-                                               state.dataWindowAC->WindAC(WindACNum).MaxIterIndex2);
+                                               windAC.MaxIterIndex2);
             }
 
         } // WindAC(WindACNum)%DXCoilType_Num == CoilDX_CoolingHXAssisted && *
@@ -1436,7 +1448,7 @@ namespace WindowAC {
             if (windowAC.OutAirVolFlow == 0 &&
                 (nodeNumber == windowAC.OutsideAirNode || nodeNumber == windowAC.MixedAirNode || nodeNumber == windowAC.AirReliefNode ||
                  nodeNumber == FanInletNodeIndex || nodeNumber == FanOutletNodeIndex || nodeNumber == windowAC.AirInNode ||
-                 nodeNumber == windowAC.CoilOutletNodeNum || nodeNumber == windowAC.AirOutNode || nodeNumber == windowAC.ReturnAirNode)) {
+                 nodeNumber == windowAC.CoilAirOutletNode || nodeNumber == windowAC.AirOutNode || nodeNumber == windowAC.ReturnAirNode)) {
                 return true;
             }
         }
@@ -1454,16 +1466,12 @@ namespace WindowAC {
         // lookup function for zone inlet node
 
         // Return value
-        int GetWindowACZoneInletAirNode;
-
         if (state.dataWindowAC->GetWindowACInputFlag) {
             GetWindowAC(state);
             state.dataWindowAC->GetWindowACInputFlag = false;
         }
 
-        GetWindowACZoneInletAirNode = state.dataWindowAC->WindAC(WindACNum).AirOutNode;
-
-        return GetWindowACZoneInletAirNode;
+        return state.dataWindowAC->WindAC(WindACNum).AirOutNode;
     }
 
     int GetWindowACOutAirNode(EnergyPlusData &state, int const WindACNum)
@@ -1494,25 +1502,19 @@ namespace WindowAC {
         // PURPOSE OF THIS FUNCTION:
         // lookup function for mixer return air node for ventilation load reporting
 
-        // Return value
-        int GetWindowACReturnAirNode;
-
         if (state.dataWindowAC->GetWindowACInputFlag) {
             GetWindowAC(state);
             state.dataWindowAC->GetWindowACInputFlag = false;
         }
 
-        if (WindACNum > 0 && WindACNum <= state.dataWindowAC->NumWindAC) {
-            if (state.dataWindowAC->WindAC(WindACNum).OAMixIndex > 0) {
-                GetWindowACReturnAirNode = MixedAir::GetOAMixerReturnNodeNumber(state, state.dataWindowAC->WindAC(WindACNum).OAMixIndex);
-            } else {
-                GetWindowACReturnAirNode = 0;
-            }
-        } else {
-            GetWindowACReturnAirNode = 0;
+        auto &windAC = state.dataWindowAC->WindAC(WindACNum);
+
+        if (WindACNum > 0 && WindACNum <= state.dataWindowAC->NumWindAC &&
+            windAC.OAMixIndex > 0) {
+          return MixedAir::GetOAMixerReturnNodeNumber(state, windAC.OAMixIndex);
         }
 
-        return GetWindowACReturnAirNode;
+        return 0;
     }
 
     int GetWindowACMixedAirNode(EnergyPlusData &state, int const WindACNum)
@@ -1525,25 +1527,17 @@ namespace WindowAC {
         // PURPOSE OF THIS FUNCTION:
         // lookup function for mixed air node for ventilation rate reporting
 
-        // Return value
-        int GetWindowACMixedAirNode;
-
         if (state.dataWindowAC->GetWindowACInputFlag) {
             GetWindowAC(state);
             state.dataWindowAC->GetWindowACInputFlag = false;
         }
 
-        if (WindACNum > 0 && WindACNum <= state.dataWindowAC->NumWindAC) {
-            if (state.dataWindowAC->WindAC(WindACNum).OAMixIndex > 0) {
-                GetWindowACMixedAirNode = MixedAir::GetOAMixerMixedNodeNumber(state, state.dataWindowAC->WindAC(WindACNum).OAMixIndex);
-            } else {
-                GetWindowACMixedAirNode = 0;
-            }
-        } else {
-            GetWindowACMixedAirNode = 0;
+        if (WindACNum > 0 && WindACNum <= state.dataWindowAC->NumWindAC && 
+            state.dataWindowAC->WindAC(WindACNum).OAMixIndex > 0) {
+            return MixedAir::GetOAMixerMixedNodeNumber(state, state.dataWindowAC->WindAC(WindACNum).OAMixIndex);
         }
 
-        return GetWindowACMixedAirNode;
+        return 0;
     }
 
     int getWindowACIndex(EnergyPlusData &state, std::string_view CompName)
diff --git a/src/EnergyPlus/WindowAC.hh b/src/EnergyPlus/WindowAC.hh
index 87ae4b7cdad..978578b8c44 100644
--- a/src/EnergyPlus/WindowAC.hh
+++ b/src/EnergyPlus/WindowAC.hh
@@ -89,13 +89,12 @@ namespace WindowAC {
         std::string FanName;   // name of fan
         HVAC::FanType fanType; // index to fan type
         int FanIndex;
-        std::string DXCoilName; // name of cooling coil
-        std::string DXCoilType; // type of cooling coil,Coil:DX:CoolingBypassFactorEmpirical or
+        std::string CoilName; // name of cooling coil
         // 'CoilSystem:Cooling:DX:HeatExchangerAssisted'
-        int DXCoilType_Num;                       // Numeric Equivalent for DXCoil Type
-        int DXCoilIndex;                          // Index to DX cooling coil
-        int DXCoilNumOfSpeeds;                    // number of speed levels for variable speed DX coil
-        int CoilOutletNodeNum;                    // Outlet node number of DX cooling coil
+        HVAC::CoilType coilType = HVAC::CoilType::Invalid;                       // Numeric Equivalent for DXCoil Type
+        int CoilNum = 0;                          // Index to DX cooling coil
+        int CoilNumOfSpeeds;                    // number of speed levels for variable speed DX coil
+        int CoilAirOutletNode = 0;                    // Outlet node number of DX cooling coil
         HVAC::FanOp fanOp = HVAC::FanOp::Invalid; // mode of operation; 1=cycling fan, cycling compressor,
         // 2=continuous fan, cycling compresor
         HVAC::FanPlace fanPlace; // fan placement; 1=blow through, 2=draw through
@@ -126,8 +125,8 @@ namespace WindowAC {
         // Default Constructor
         WindACData()
             : UnitType(0), MaxAirVolFlow(0.0), MaxAirMassFlow(0.0), OutAirVolFlow(0.0), OutAirMassFlow(0.0), AirInNode(0), AirOutNode(0),
-              OutsideAirNode(0), AirReliefNode(0), MixedAirNode(0), OAMixIndex(0), fanType(HVAC::FanType::Invalid), FanIndex(0), DXCoilType_Num(0),
-              DXCoilIndex(0), DXCoilNumOfSpeeds(0), CoilOutletNodeNum(0), fanPlace(HVAC::FanPlace::Invalid), MaxIterIndex1(0), MaxIterIndex2(0),
+              OutsideAirNode(0), AirReliefNode(0), MixedAirNode(0), OAMixIndex(0), fanType(HVAC::FanType::Invalid), FanIndex(0), 
+              CoilNumOfSpeeds(0), fanPlace(HVAC::FanPlace::Invalid), MaxIterIndex1(0), MaxIterIndex2(0),
               ConvergenceTol(0.0), PartLoadFrac(0.0), EMSOverridePartLoadFrac(false), EMSValueForPartLoadFrac(0.0), TotCoolEnergyRate(0.0),
               TotCoolEnergy(0.0), SensCoolEnergyRate(0.0), SensCoolEnergy(0.0), LatCoolEnergyRate(0.0), LatCoolEnergy(0.0), ElecPower(0.0),
               ElecConsumption(0.0), FanPartLoadRatio(0.0), CompPartLoadRatio(0.0), ZonePtr(0), HVACSizingIndex(0), FirstPass(true)
diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc
index 7e5f555ce88..3aeb0fb830c 100644
--- a/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc
+++ b/tst/EnergyPlus/unit/AirTerminalSingleDuct.unit.cc
@@ -408,8 +408,8 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctVAVHeatCool_GetInputTest)
 
     EXPECT_EQ("AirTerminal:SingleDuct:VAV:HeatAndCool:Reheat", state->dataSingleDuct->sd_airterminal(1).sysType); // AT SD VAV HeatCool Reheat Type
     EXPECT_EQ("ZONE 1 VAV SYSTEM", state->dataSingleDuct->sd_airterminal(1).SysName);                             // AT SD VAV HeatCool Reheat Name
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", state->dataSingleDuct->sd_airterminal(1).ReheatComp);                      // Reheat Coil Type
-    EXPECT_EQ("REHEAT COIL ZONE 1", state->dataSingleDuct->sd_airterminal(1).ReheatName);                         // Reheat Coil Name
+    EXPECT_EQ(state->dataSingleDuct->sd_airterminal(1).reheatCoilType, HVAC::CoilType::HeatingElectric);                    // Reheat Coil Type
+    EXPECT_EQ("REHEAT COIL ZONE 1", state->dataSingleDuct->sd_airterminal(1).ReheatCoilName);                         // Reheat Coil Name
 }
 
 TEST_F(EnergyPlusFixture, AirTerminalSingleDuctVAVReheatVarSpeedFan_GetInputTest)
@@ -532,8 +532,8 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctVAVReheatVarSpeedFan_GetInputTest
     EXPECT_EQ("AirTerminal:SingleDuct:VAV:Reheat:VariableSpeedFan",
               state->dataSingleDuct->sd_airterminal(1).sysType);                          // AT SD VAV HeatCool Reheat Type
     EXPECT_EQ("SPACE1-1 VAV REHEAT", state->dataSingleDuct->sd_airterminal(1).SysName);   // AT SD VAV HeatCool Reheat Name
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataSingleDuct->sd_airterminal(1).ReheatComp); // Reheat Coil Type
-    EXPECT_EQ("SPACE1-1 ZONE COIL", state->dataSingleDuct->sd_airterminal(1).ReheatName); // Reheat Coil Name
+    EXPECT_EQ(HVAC::CoilType::HeatingWater, state->dataSingleDuct->sd_airterminal(1).reheatCoilType); // Reheat Coil Type
+    EXPECT_EQ("SPACE1-1 ZONE COIL", state->dataSingleDuct->sd_airterminal(1).ReheatCoilName); // Reheat Coil Name
 }
 
 TEST_F(EnergyPlusFixture, AirTerminalSingleDuctVAVReheat_NormalActionTest)
@@ -647,7 +647,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctVAVReheat_NormalActionTest)
     Real64 MassFlowRateMaxAvail = state->dataSingleDuct->sd_airterminal(SysNum).MaxAirVolFlowRate * state->dataEnvrn->StdRhoAir;
     EXPECT_EQ(1.0, state->dataSingleDuct->sd_airterminal(SysNum).MaxAirVolFlowRate);
     EXPECT_EQ(1.0, MassFlowRateMaxAvail);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", state->dataSingleDuct->sd_airterminal(SysNum).ReheatComp);
+    EXPECT_EQ(HVAC::CoilType::HeatingElectric, state->dataSingleDuct->sd_airterminal(SysNum).reheatCoilType);
     EXPECT_ENUM_EQ(Action::Normal, state->dataSingleDuct->sd_airterminal(SysNum).DamperHeatingAction);
     EXPECT_EQ(0.2, state->dataSingleDuct->sd_airterminal(SysNum).ZoneMinAirFracDes);
 
@@ -1628,8 +1628,8 @@ TEST_F(EnergyPlusFixture, SingleDuctVAVReheatVSFan_DamperPositionTest)
     int InletNodeNum = Util::FindItemInList("ZONE 1 ATU IN NODE", state->dataLoopNodes->NodeID);
     EXPECT_EQ("AirTerminal:SingleDuct:VAV:Reheat:VariableSpeedFan", thisAirTerminal.sysType);
     EXPECT_EQ("VAV RHT VS FAN AIRTERM", thisAirTerminal.SysName);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", thisAirTerminal.ReheatComp);
-    EXPECT_EQ("ZONE 1 REHEAT COIL", thisAirTerminal.ReheatName);
+    EXPECT_EQ(HVAC::CoilType::HeatingElectric, thisAirTerminal.reheatCoilType);
+    EXPECT_EQ("ZONE 1 REHEAT COIL", thisAirTerminal.ReheatCoilName);
     EXPECT_EQ((int)HVAC::FanType::SystemModel, (int)thisAirTerminal.fanType);
     EXPECT_EQ("ZONE 1 VS FAN", thisAirTerminal.FanName);
     EXPECT_EQ(1.0, thisAirTerminal.MaxAirVolFlowRate);
@@ -1869,8 +1869,8 @@ TEST_F(EnergyPlusFixture, SingleDuctInduction_reportTerminalUnit)
     sdiu(1).UnitType = "AirTerminal:SingleDuct:ConstantVolume:FourPipeInduction";
     sdiu(1).MaxPriAirMassFlow = 0.30;
     sdiu(1).MaxSecAirMassFlow = 0.15;
-    sdiu(1).HCoilType = "hotwatercoil";
-    sdiu(1).CCoilType = "coldwatercoil";
+    sdiu(1).heatCoilType = HVAC::CoilType::HeatingWater;
+    sdiu(1).coolCoilType = HVAC::CoilType::CoolingWater;
 
     sdiu(1).reportTerminalUnit(*state);
 
@@ -1886,8 +1886,8 @@ TEST_F(EnergyPlusFixture, SingleDuctInduction_reportTerminalUnit)
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU a"));
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU a"));
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a"));
-    EXPECT_EQ("hotwatercoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a"));
-    EXPECT_EQ("coldwatercoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a"));
+    EXPECT_EQ("Coil:Heating:Water", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a"));
+    EXPECT_EQ("Coil:Cooling:Water", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a"));
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a"));
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a"));
 }
diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc
index 58ae4aa0a70..ef81f7dd380 100644
--- a/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc
+++ b/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc
@@ -7729,10 +7729,10 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest)
     EXPECT_EQ((int)HVAC::MixerType::InletSide, (int)thisATMixer.type);                                  // air terminal mixer connection type
     EXPECT_EQ("AIRTERMINAL:SINGLEDUCT:MIXER", state->dataDefineEquipment->AirDistUnit(1).EquipType(1)); // Air distribution unit equipment type
     EXPECT_EQ((int)HVAC::FanType::VAV, (int)thisFanCoil.fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("FCU COOLING COIL", thisFanCoil.CCoilName);
-    EXPECT_EQ("COIL:HEATING:WATER", thisFanCoil.HCoilType);
-    EXPECT_EQ("FCU HEATING COIL", thisFanCoil.HCoilName);
+    EXPECT_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_EQ("FCU COOLING COIL", thisFanCoil.CoolCoilName);
+    EXPECT_EQ(HVAC::CoilType::HeatingWater, thisFanCoil.heatCoilType);
+    EXPECT_EQ("FCU HEATING COIL", thisFanCoil.HeatCoilName);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -7740,7 +7740,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest)
     state->dataSize->PlantSizData.allocate(state->dataSize->NumPltSizInput);
     // chilled water coil
     auto &CWCoil(state->dataWaterCoils->WaterCoil(2));
-    thisFanCoil.CCoilName_Index = 2;
+    thisFanCoil.CoolCoilNum = 2;
     state->dataLoopNodes->Node(CWCoil.WaterInletNodeNum).Temp = 6.0;
     CWCoil.WaterPlantLoc.loopNum = 2;
     CWCoil.WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
@@ -7748,7 +7748,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest)
     CWCoil.WaterPlantLoc.compNum = 1;
     // hot water coil
     auto &HWCoil(state->dataWaterCoils->WaterCoil(1));
-    thisFanCoil.HCoilName_Index = 1;
+    thisFanCoil.HeatCoilNum = 1;
     state->dataLoopNodes->Node(HWCoil.WaterInletNodeNum).Temp = 60.0;
     HWCoil.WaterPlantLoc.loopNum = 1;
     HWCoil.WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
@@ -8144,15 +8144,15 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest)
     // get input test for terminal air single duct mixer on inlet side of PTAC
     ASSERT_EQ(1, state->dataSingleDuct->NumATMixers);
     EXPECT_EQ("INLET SIDE MIXER", thisATMixer.Name);                                                    // single duct air terminal mixer name
-    EXPECT_EQ((int)HVAC::MixerType::InletSide, (int)thisATMixer.type);                                  // air terminal mixer connection type
+    EXPECT_ENUM_EQ(HVAC::MixerType::InletSide, thisATMixer.type);                                  // air terminal mixer connection type
     EXPECT_EQ("AIRTERMINAL:SINGLEDUCT:MIXER", state->dataDefineEquipment->AirDistUnit(1).EquipType(1)); // Air distribution unit equipment type
-    EXPECT_EQ((int)HVAC::FanType::VAV, (int)thisFanCoil.fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("FCU COOLING COIL", thisFanCoil.CCoilName);
-    EXPECT_EQ("COIL:HEATING:WATER", thisFanCoil.HCoilType);
-    EXPECT_EQ("FCU HEATING COIL", thisFanCoil.HCoilName);
+    EXPECT_ENUM_EQ(HVAC::FanType::VAV, thisFanCoil.fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_EQ("FCU COOLING COIL", thisFanCoil.CoolCoilName);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, thisFanCoil.heatCoilType);
+    EXPECT_EQ("FCU HEATING COIL", thisFanCoil.HeatCoilName);
     EXPECT_EQ("NIGHTCYCLE AVAILMGR", thisAvaiManager.Name);
-    EXPECT_EQ((int)Avail::ManagerType::NightCycle, (int)thisAvaiManager.type);
+    EXPECT_ENUM_EQ(Avail::ManagerType::NightCycle, thisAvaiManager.type);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -8160,7 +8160,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest)
     state->dataSize->PlantSizData.allocate(state->dataSize->NumPltSizInput);
     // chilled water coil
     auto &CWCoil(state->dataWaterCoils->WaterCoil(2));
-    thisFanCoil.CCoilName_Index = 2;
+    thisFanCoil.CoolCoilNum = 2;
     state->dataLoopNodes->Node(CWCoil.WaterInletNodeNum).Temp = 6.0;
     CWCoil.WaterPlantLoc.loopNum = 2;
     CWCoil.WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
@@ -8168,7 +8168,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest)
     CWCoil.WaterPlantLoc.compNum = 1;
     // hot water coil
     auto &HWCoil(state->dataWaterCoils->WaterCoil(1));
-    thisFanCoil.HCoilName_Index = 1;
+    thisFanCoil.HeatCoilNum = 1;
     state->dataLoopNodes->Node(HWCoil.WaterInletNodeNum).Temp = 60.0;
     HWCoil.WaterPlantLoc.loopNum = 1;
     HWCoil.WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
@@ -8292,8 +8292,8 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest)
     state->dataGlobal->BeginEnvrnFlag = true;
     state->dataSize->ZoneEqFanCoil = true;
     // check availability manager Night Cycle parameters
-    EXPECT_EQ((int)Avail::CyclingRunTimeControl::ThermostatWithMinimumRunTime, (int)state->dataAvail->NightCycleData(1).cyclingRunTimeControl);
-    EXPECT_EQ((int)Avail::Status::NoAction, (int)state->dataAvail->NightCycleData(1).availStatus);
+    EXPECT_ENUM_EQ(Avail::CyclingRunTimeControl::ThermostatWithMinimumRunTime, state->dataAvail->NightCycleData(1).cyclingRunTimeControl);
+    EXPECT_ENUM_EQ(Avail::Status::NoAction, state->dataAvail->NightCycleData(1).availStatus);
 
     // set predicted heating load
     zoneSysEnergyDemand.RemainingOutputReqToCoolSP = 4000.0;
diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuctPIUReheat.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuctPIUReheat.unit.cc
index 86898202662..33a1cf516d6 100644
--- a/tst/EnergyPlus/unit/AirTerminalSingleDuctPIUReheat.unit.cc
+++ b/tst/EnergyPlus/unit/AirTerminalSingleDuctPIUReheat.unit.cc
@@ -188,9 +188,8 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctSeriesPIUReheat_GetInputtest)
     GetPIUs(*state);
 
     ASSERT_EQ(1, state->dataPowerInductionUnits->NumSeriesPIUs);
-    EXPECT_EQ("SPACE1-1 ZONE COIL", state->dataPowerInductionUnits->PIU(1).HCoil); // heating coil name
-    EXPECT_EQ("COIL:HEATING:WATER",
-              HCoilNamesUC[static_cast<int>(state->dataPowerInductionUnits->PIU(1).HCoilType)]); // hot water heating coil
+    EXPECT_EQ("SPACE1-1 ZONE COIL", state->dataPowerInductionUnits->PIU(1).heatCoilName); // heating coil name
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataPowerInductionUnits->PIU(1).heatCoilType); // hot water heating coil
     EXPECT_GT(state->dataPowerInductionUnits->PIU(1).HotControlNode, 0);                         // none zero integer node index is expected
 }
 
diff --git a/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc b/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc
index ae8ea7420eb..a6cd8bbeda7 100644
--- a/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc
+++ b/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc
@@ -11251,7 +11251,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestNoZoneEqpSupportZoneERV)
     state->dataHVACStandAloneERV->StandAloneERV(1).ExhaustAirFanName = state->dataFans->fans(2)->Name;
     state->dataHVACStandAloneERV->StandAloneERV(1).ExhaustAirFanIndex = 2;
     state->dataHVACStandAloneERV->StandAloneERV(1).hxType = HVAC::HXType::AirToAir_Generic;
-    state->dataHVACStandAloneERV->StandAloneERV(1).HeatExchangerName = "ERV Heat Exchanger";
+    state->dataHVACStandAloneERV->StandAloneERV(1).hxName = "ERV Heat Exchanger";
 
     // Check validation and expected errors
     ASSERT_THROW(state->afn->validate_distribution(), std::runtime_error);
@@ -11444,7 +11444,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneEqpSupportZoneERV)
     state->dataHVACStandAloneERV->StandAloneERV(1).ExhaustAirFanName = state->dataFans->fans(2)->Name;
     state->dataHVACStandAloneERV->StandAloneERV(1).ExhaustAirFanIndex = 2;
     state->dataHVACStandAloneERV->StandAloneERV(1).hxType = HVAC::HXType::AirToAir_Generic;
-    state->dataHVACStandAloneERV->StandAloneERV(1).HeatExchangerName = "ERV Heat Exchanger";
+    state->dataHVACStandAloneERV->StandAloneERV(1).hxName = "ERV Heat Exchanger";
 
     // Check validation and expected warning
     state->afn->validate_distribution();
@@ -11622,7 +11622,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneEqpSupportUnbalancedZoneERV)
     state->dataHVACStandAloneERV->StandAloneERV(1).ExhaustAirFanName = fan2->Name;
     state->dataHVACStandAloneERV->StandAloneERV(1).ExhaustAirFanIndex = 2;
     state->dataHVACStandAloneERV->StandAloneERV(1).hxType = HVAC::HXType::AirToAir_Generic;
-    state->dataHVACStandAloneERV->StandAloneERV(1).HeatExchangerName = "ERV Heat Exchanger";
+    state->dataHVACStandAloneERV->StandAloneERV(1).hxName = "ERV Heat Exchanger";
 
     // Check validation and expected errors
     ASSERT_THROW(state->afn->validate_distribution(), std::runtime_error);
@@ -16928,6 +16928,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_CheckMultistageHeatingCoil)
     state->afn->DisSysCompCoilData(2).AirLoopNum = 2;
 
     state->dataHeatingCoils->GetCoilsInputFlag = false;
+    state->dataHeatingCoils->NumHeatingCoils = 2;
     state->dataHeatingCoils->HeatingCoil.allocate(2);
     state->dataHeatingCoils->HeatingCoil(1).Name = "ElectricCoil";
     state->dataHeatingCoils->HeatingCoil(2).Name = "GasCoil";
diff --git a/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc
index 11907447a7e..a84b664e99a 100644
--- a/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc
@@ -76,7 +76,7 @@ TEST_F(AutoSizingFixture, AutoCalculateSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -95,7 +95,7 @@ TEST_F(AutoSizingFixture, AutoCalculateSizingGauntlet)
     std::string sizingString = "Any sizing that requires AutoCalculate []";
     sizer.overrideSizingString(sizingString);
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -116,7 +116,7 @@ TEST_F(AutoSizingFixture, AutoCalculateSizingGauntlet)
     // Test 2 - start with autosized value
     sizer.wasAutoSized = false;
     inputValue = DataSizing::AutoSize;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -126,7 +126,7 @@ TEST_F(AutoSizingFixture, AutoCalculateSizingGauntlet)
     // Test 3 - start with autosized value, Data globals were not set again
     sizer.wasAutoSized = false;
     inputValue = DataSizing::AutoSize;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType); // Data globals weren't set
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -141,7 +141,7 @@ TEST_F(AutoSizingFixture, AutoCalculateSizingGauntlet)
     state->dataSize->DataEMSOverride = 33.4;
     sizer.wasAutoSized = false;
     inputValue = 28.8;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -158,7 +158,7 @@ TEST_F(AutoSizingFixture, AutoCalculateSizingGauntlet)
     // Test 5 - EMS override on, autosized input
     sizer.wasAutoSized = false;
     inputValue = DataSizing::AutoSize;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -190,7 +190,7 @@ TEST_F(AutoSizingFixture, MaxHeaterOutletTempSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -203,7 +203,7 @@ TEST_F(AutoSizingFixture, MaxHeaterOutletTempSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -226,7 +226,7 @@ TEST_F(AutoSizingFixture, MaxHeaterOutletTempSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -254,7 +254,7 @@ TEST_F(AutoSizingFixture, MaxHeaterOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -275,7 +275,7 @@ TEST_F(AutoSizingFixture, MaxHeaterOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -291,7 +291,7 @@ TEST_F(AutoSizingFixture, MaxHeaterOutletTempSizingGauntlet)
     // Test 5 - Airloop Equipment
     sizer.wasAutoSized = false;
     inputValue = 28.8;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -324,7 +324,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -337,7 +337,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -360,7 +360,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -388,7 +388,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -409,7 +409,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -424,7 +424,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     // Test 5 - Airloop Equipment
     sizer.wasAutoSized = false;
     inputValue = 2880.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -458,7 +458,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -471,7 +471,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -494,7 +494,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -522,7 +522,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -542,7 +542,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -557,7 +557,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     // Test 5 - Airloop Equipment
     sizer.wasAutoSized = false;
     inputValue = 2880.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -591,7 +591,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -604,7 +604,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -630,7 +630,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -642,7 +642,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -667,7 +667,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -688,7 +688,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     // do sizing, DataAirFlowUsedForSizing = 0
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(errorsFound);
@@ -708,7 +708,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -724,7 +724,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     // Test 7 - Airloop Equipment
     sizer.wasAutoSized = false;
     inputValue = 9.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -758,7 +758,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -771,7 +771,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -797,7 +797,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -809,7 +809,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -835,7 +835,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -856,7 +856,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -872,7 +872,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     // Test 5 - Airloop Equipment
     sizer.wasAutoSized = false;
     inputValue = 32.3;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -890,7 +890,7 @@ TEST_F(AutoSizingFixture, ASHRAEMaxSATHeatingSizingGauntlet)
     sizer.wasAutoSized = false;
     state->dataSize->DataCapacityUsedForSizing = 0.0;
     inputValue = DataSizing::AutoSize;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1066,7 +1066,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletTempSizingGauntlet)
     // ZONE EQUIPMENT TESTING - Zone equipment not supported
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -1088,7 +1088,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -1107,7 +1107,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
 
     // DataDesicRegCoil not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1121,7 +1121,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletTempSizingGauntlet)
     state->dataDesiccantDehumidifiers->DesicDehum.allocate(1);
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1136,7 +1136,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletTempSizingGauntlet)
 
     // Test 5 - Airloop Equipment w/ desiccant regen coil in OA system
     state->dataDesiccantDehumidifiers->DesicDehum(1).RegenInletIsOutsideAirNode = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1150,7 +1150,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletTempSizingGauntlet)
     // Test 6 - Airloop Equipment - hard-sized desiccant regen coil in OA system
     sizer.wasAutoSized = false;
     inputValue = 19.8;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -1182,7 +1182,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirOutletTempSizingGauntlet)
     // ZONE EQUIPMENT TESTING - Zone equipment not supported
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -1204,7 +1204,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -1223,7 +1223,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirOutletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
 
     // DataDesicRegCoil not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1238,7 +1238,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirOutletTempSizingGauntlet)
     state->dataDesiccantDehumidifiers->DesicDehum(1).RegenSetPointTemp = 26.4;
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1254,7 +1254,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirOutletTempSizingGauntlet)
     // Test 5 - Airloop Equipment - hard-sized desiccant regen coil in OA system
     sizer.wasAutoSized = false;
     inputValue = 32.8;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -1287,7 +1287,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
     // ZONE EQUIPMENT TESTING - Zone equipment not supported
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -1309,7 +1309,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -1328,7 +1328,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
 
     // DataDesicRegCoil not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1342,7 +1342,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
     state->dataDesiccantDehumidifiers->DesicDehum.allocate(1);
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1357,7 +1357,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
 
     // Test 5 - Airloop Equipment w/ desiccant regen coil in OA system
     state->dataDesiccantDehumidifiers->DesicDehum(1).RegenInletIsOutsideAirNode = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -1371,7 +1371,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
     // Test 6 - Airloop Equipment - hard-sized desiccant regen coil in OA system
     sizer.wasAutoSized = false;
     inputValue = 0.009;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc
index bc48e5a5878..64f11d8b1d5 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc
@@ -82,7 +82,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     state->dataSize->CurTermUnitSizingNum = 1;
     state->dataSize->TermUnitSingDuct = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -95,7 +95,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -140,7 +140,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -157,7 +157,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -170,7 +170,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -182,7 +182,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -197,7 +197,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -210,7 +210,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -223,7 +223,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -237,7 +237,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -251,7 +251,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -263,7 +263,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -280,7 +280,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -294,7 +294,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -306,7 +306,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -318,7 +318,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -331,7 +331,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -343,7 +343,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -358,7 +358,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -371,7 +371,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -384,7 +384,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -397,7 +397,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -409,7 +409,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -422,7 +422,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -440,7 +440,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -453,7 +453,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -466,7 +466,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -479,7 +479,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -491,7 +491,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -504,7 +504,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -518,7 +518,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -531,7 +531,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -544,7 +544,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -557,7 +557,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -569,7 +569,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -582,7 +582,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -594,7 +594,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     state->dataSize->ZoneEqSizing(1).AirVolFlow = 1.75;
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -605,7 +605,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // Test 37 - Zone Equipment, hard size with zone sizing run
     inputValue = 1.44;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -616,7 +616,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = 1.44;
     state->dataSize->ZoneSizingRunDone = false;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -629,7 +629,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = 1.44;
     state->dataSize->ZoneSizingRunDone = false;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -658,7 +658,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -687,7 +687,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -713,7 +713,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -732,7 +732,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -748,7 +748,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -767,7 +767,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -781,7 +781,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -796,7 +796,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -812,7 +812,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -830,7 +830,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -843,7 +843,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -857,7 +857,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -871,7 +871,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -884,7 +884,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -898,7 +898,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -915,7 +915,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -940,7 +940,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -965,7 +965,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc
index 412ee1544c3..481931e4fd3 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc
@@ -113,7 +113,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     state->dataSize->TermUnitSingDuct = true;
 
     // Test #1 - Zone Equipment, no autosizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -130,7 +130,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
 
     state->dataSize->ZoneEqSizing(1).DesignSizeFromParent = true;
     state->dataSize->ZoneEqSizing(1).DesCoolingLoad = sizedValue;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -170,7 +170,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.zoneSizingInput.allocate(1);
     sizer.zoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -186,7 +186,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -200,7 +200,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilWater_CoolingHXAssisted), "MyHXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWaterHXAssisted], "MyHXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -214,7 +214,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -228,7 +228,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -242,7 +242,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -256,7 +256,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -272,7 +272,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     inputValue = 5500.0;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -305,7 +305,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -332,7 +332,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -347,7 +347,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -363,7 +363,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -393,7 +393,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -413,7 +413,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -432,7 +432,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -447,7 +447,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -463,7 +463,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -481,7 +481,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -509,7 +509,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -525,7 +525,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -561,7 +561,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc
index 6a4e42bbd3d..685237e2c6b 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc
@@ -87,7 +87,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
 
     // Test #1 - Zone Equipment, no autosizing, missing input data
     state->dataSize->DataFlowUsedForSizing = 0.5; // DataCapacityUsedForSizing not initialized
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // no sizing error since not autosized
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -103,7 +103,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     printFlag = true;
     inputValue = 0.85;
     state->dataSize->DataCapacityUsedForSizing = 10000.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -131,7 +131,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -147,7 +147,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     // Test #4 - Zone Equipment, repeat with autosized and no initialized DataCapacityUsedForSizing
     inputValue = DataSizing::AutoSize;
     state->dataSize->DataCapacityUsedForSizing = 0.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(errorsFound);
@@ -157,7 +157,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     // Test #5 - Zone Equipment, flow to capacity ratio high
     state->dataSize->DataCapacityUsedForSizing = 10000.0;
     state->dataSize->DataFlowUsedForSizing = 1.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // missing Data* globals and Plant data
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -173,7 +173,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -194,7 +194,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     state->dataHVACGlobal->DXCT = HVAC::DXCoilType::DOAS;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -212,7 +212,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
 
     // Test #8 - Zone Equipment, flow to capacity ratio high
     state->dataSize->DataFlowUsedForSizing = 1.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // missing Data* globals and Plant data
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -229,7 +229,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -260,7 +260,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -282,7 +282,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -303,7 +303,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -318,7 +318,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -340,7 +340,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc
index c876948f0ad..ce9969a9787 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc
@@ -83,7 +83,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     has_eio_output(true);
 
     // Test #1 - Zone Equipment, no autosizing, TU type not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -96,7 +96,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
 
     // Test #2 - Zone Equipment, no autosizing, TU type not set
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -135,7 +135,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -153,7 +153,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -168,7 +168,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -183,7 +183,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -197,7 +197,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -214,7 +214,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -243,7 +243,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -265,7 +265,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -289,7 +289,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -304,7 +304,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -322,7 +322,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -341,7 +341,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -358,7 +358,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletTempSizing.unit.cc
index 1f2b8b0b17b..fccb5a1c6d8 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletTempSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletTempSizing.unit.cc
@@ -84,7 +84,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     has_eio_output(true);
 
     // Test #1 - Zone Equipment, no autosizing, TU type not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -97,7 +97,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
 
     // Test #2 - Zone Equipment, no autosizing, TU type not set
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -137,7 +137,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -155,7 +155,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -170,7 +170,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -200,7 +200,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -216,7 +216,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -230,7 +230,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -247,7 +247,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -277,7 +277,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -302,7 +302,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     state->dataAirSystemsData->PrimaryAirSystems(state->dataSize->CurSysNum).NumOACoolCoils = 1;
     state->dataSize->DataDesInletAirTemp = 19.155;
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -318,7 +318,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -341,7 +341,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -356,7 +356,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -373,7 +373,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -392,7 +392,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -409,7 +409,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc
index f71ac717b46..199b1636dcf 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc
@@ -83,7 +83,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     has_eio_output(true);
 
     // Test #1 - Zone Equipment, no autosizing, TU type not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -96,7 +96,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     // Test #2 - Zone Equipment, no autosizing, TU type not set
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -130,7 +130,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -148,7 +148,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -163,7 +163,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -178,7 +178,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -208,7 +208,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -233,7 +233,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -258,7 +258,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -272,7 +272,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -291,7 +291,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -310,7 +310,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -326,7 +326,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -353,7 +353,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -377,7 +377,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc
index 425e1aeb2e8..27bb35c21df 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletTempSizing.unit.cc
@@ -86,7 +86,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     has_eio_output(true);
 
     // Test #1 - Zone Equipment, no autosizing, TU type not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -99,7 +99,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
 
     // Test #2 - Zone Equipment, no autosizing, TU type not set
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -137,7 +137,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -161,7 +161,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -177,7 +177,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -207,7 +207,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -223,7 +223,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -236,7 +236,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -265,7 +265,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -288,7 +288,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -310,7 +310,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -327,7 +327,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -342,7 +342,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -360,7 +360,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -379,7 +379,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -396,7 +396,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -419,7 +419,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc
index 83c23aa9313..ee4e2b45d6d 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc
@@ -76,7 +76,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->DataPltSizCoolNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -89,7 +89,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -110,7 +110,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -124,7 +124,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -138,7 +138,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -152,7 +152,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -165,7 +165,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -177,7 +177,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -189,7 +189,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -218,7 +218,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -242,7 +242,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -263,7 +263,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -276,7 +276,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -290,7 +290,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -303,7 +303,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -317,7 +317,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -334,7 +334,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -350,7 +350,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -366,7 +366,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc
index db2a1f00288..11f9442b580 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc
@@ -75,7 +75,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->DataPltSizCoolNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -88,7 +88,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -109,7 +109,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -124,7 +124,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -153,7 +153,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -175,7 +175,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -197,7 +197,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -212,7 +212,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -228,7 +228,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc
index 2cbbbd50769..f61f2ef4ad0 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc
@@ -87,7 +87,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     state->dataSize->TermUnitSizing(1).MaxCWVolFlow = 0.005;
 
     // Test #1 - Zone Equipment, no autosizing, missing input data
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -99,7 +99,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     state->dataPlnt->PlantLoop.allocate(1);
     state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state);
     state->dataSize->DataWaterCoilSizCoolDeltaT = 10.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -110,7 +110,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -144,7 +144,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -174,7 +174,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
 
     state->dataSize->DataFanIndex = Fans::GetFanIndex(*state, "CONSTANT FAN 1");
     state->dataSize->DataFanType = HVAC::FanType::Constant;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // missing Data* globals and Plant data
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -197,7 +197,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -211,7 +211,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -226,7 +226,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -241,7 +241,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -255,7 +255,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -286,7 +286,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -307,7 +307,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -335,7 +335,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc
index aed65f9df45..bf501cc07d9 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc
@@ -82,7 +82,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     state->dataSize->CurTermUnitSizingNum = 1;
     state->dataSize->TermUnitSingDuct = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -95,7 +95,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -140,7 +140,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -157,7 +157,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -170,7 +170,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -182,7 +182,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -197,7 +197,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -210,7 +210,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -223,7 +223,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -237,7 +237,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -251,7 +251,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -263,7 +263,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -280,7 +280,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -294,7 +294,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -306,7 +306,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -318,7 +318,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -331,7 +331,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -343,7 +343,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -358,7 +358,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -371,7 +371,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -384,7 +384,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -397,7 +397,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -409,7 +409,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -422,7 +422,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -440,7 +440,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -453,7 +453,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -466,7 +466,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -479,7 +479,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -491,7 +491,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -504,7 +504,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -518,7 +518,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -531,7 +531,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -544,7 +544,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -557,7 +557,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -569,7 +569,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -582,7 +582,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -594,7 +594,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     state->dataSize->ZoneEqSizing(1).AirVolFlow = 1.75;
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -605,7 +605,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // Test 37 - Zone Equipment, hard size with zone sizing run
     inputValue = 1.44;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -616,7 +616,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = 1.44;
     state->dataSize->ZoneSizingRunDone = false;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -629,7 +629,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = 1.44;
     state->dataSize->ZoneSizingRunDone = false;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -658,7 +658,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -687,7 +687,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -713,7 +713,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -732,7 +732,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -749,7 +749,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -768,7 +768,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -782,7 +782,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -797,7 +797,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -813,7 +813,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -831,7 +831,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -844,7 +844,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -858,7 +858,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -872,7 +872,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -885,7 +885,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -899,7 +899,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -916,7 +916,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -941,7 +941,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -966,7 +966,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc
index 60c4b3d2710..25b039e949e 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc
@@ -104,7 +104,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     state->dataSize->CurTermUnitSizingNum = 1;
     state->dataSize->TermUnitSingDuct = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -117,7 +117,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -148,7 +148,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -165,7 +165,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -180,7 +180,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -194,7 +194,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -210,7 +210,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -227,7 +227,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -243,7 +243,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -258,7 +258,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -287,7 +287,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -311,7 +311,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -333,7 +333,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -347,7 +347,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -364,7 +364,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -378,7 +378,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -395,7 +395,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -414,7 +414,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -431,7 +431,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -449,7 +449,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc
index 64169bf8f3c..a02ff8c592b 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc
@@ -112,7 +112,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     state->dataSize->TermUnitSingDuct = true;
 
     // Test #1 - Zone Equipment, no autosizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -129,7 +129,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
 
     state->dataSize->ZoneEqSizing(1).DesignSizeFromParent = true;
     state->dataSize->ZoneEqSizing(1).DesHeatingLoad = sizedValue;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -177,7 +177,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     // do sizing
     sizer.zoneSizingInput.allocate(1);
     sizer.zoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -192,7 +192,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -206,7 +206,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_HeatingEmpirical), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -219,7 +219,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -233,7 +233,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -247,7 +247,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -261,7 +261,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -275,7 +275,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -288,7 +288,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -302,7 +302,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -316,7 +316,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -331,7 +331,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -347,7 +347,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_CoolingSingleSpeed), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -364,7 +364,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = 5500.0;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -396,7 +396,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -427,7 +427,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -442,7 +442,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -459,7 +459,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -473,7 +473,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -489,7 +489,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -505,7 +505,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -520,7 +520,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -534,7 +534,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -547,7 +547,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -561,7 +561,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -574,7 +574,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -588,7 +588,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -601,7 +601,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -614,7 +614,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -630,7 +630,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -643,7 +643,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::CoilDX_HeatingEmpirical), "MyDXCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingDXSingleSpeed], "MyDXCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -657,7 +657,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -672,7 +672,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -689,7 +689,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -703,7 +703,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -720,7 +720,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -734,7 +734,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -749,7 +749,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -764,7 +764,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -781,7 +781,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -805,7 +805,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -821,7 +821,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc
index a70c284cec0..b228d6aee01 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc
@@ -83,7 +83,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     has_eio_output(true);
 
     // Test #1 - Zone Equipment, no autosizing, TU type not set
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -96,7 +96,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
 
     // Test #2 - Zone Equipment, no autosizing, TU type not set
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -145,7 +145,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -164,7 +164,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -177,7 +177,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -194,7 +194,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -209,7 +209,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -222,7 +222,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -237,7 +237,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -253,7 +253,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -271,7 +271,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -286,7 +286,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -315,7 +315,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -341,7 +341,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -365,7 +365,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -381,7 +381,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -398,7 +398,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -417,7 +417,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -434,7 +434,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc
index 8b3776838ca..d2d45ede405 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc
@@ -82,7 +82,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     state->dataSize->CurTermUnitSizingNum = 1;
     state->dataSize->TermUnitSingDuct = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -95,7 +95,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -126,7 +126,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.zoneSizingInput.allocate(1);
     sizer.zoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -141,7 +141,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -155,7 +155,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -169,7 +169,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -182,7 +182,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -194,7 +194,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -206,7 +206,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -235,7 +235,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -261,7 +261,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -281,7 +281,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -294,7 +294,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -308,7 +308,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -321,7 +321,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -335,7 +335,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -352,7 +352,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -368,7 +368,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -384,7 +384,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc
index 3e35974ef8e..9deca07ccde 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc
@@ -83,7 +83,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     state->dataSize->CurTermUnitSizingNum = 1;
     state->dataSize->TermUnitSingDuct = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing (this sizer is not typically hard-sized)
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -96,7 +96,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -147,7 +147,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     // do sizing
     sizer.zoneSizingInput.allocate(1);
     sizer.zoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -162,7 +162,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -176,7 +176,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -190,7 +190,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -203,7 +203,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -219,7 +219,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -235,7 +235,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -249,7 +249,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -264,7 +264,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     inputValue = 1500.0;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -300,7 +300,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -328,7 +328,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -350,7 +350,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -380,7 +380,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -396,7 +396,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -411,7 +411,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -428,7 +428,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -445,7 +445,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -461,7 +461,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc
index 5077750d34a..98eeee77770 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc
@@ -75,7 +75,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     state->dataSize->DataPltSizHeatNum = 1;
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -88,7 +88,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -112,7 +112,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -130,7 +130,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -147,7 +147,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -175,7 +175,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -196,7 +196,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -219,7 +219,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -234,7 +234,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -250,7 +250,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc
index 40f00eb6671..30b7a5984be 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc
@@ -80,7 +80,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     // test auto calculate
     state->dataSize->DataFractionUsedForSizing = 0.0;
     state->dataSize->DataConstantUsedForSizing = 1.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     // developer errror, DataFractionUsedForSizing = 0 and Constant > 0
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
@@ -91,7 +91,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
 
     state->dataSize->DataFractionUsedForSizing = 1.0;
     state->dataSize->DataConstantUsedForSizing = 0.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -101,7 +101,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
 
     state->dataSize->DataFractionUsedForSizing = 1.0;
     state->dataSize->DataConstantUsedForSizing = 1.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -112,7 +112,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     state->dataSize->DataFractionUsedForSizing = 1.0;
     state->dataSize->DataConstantUsedForSizing = 2.0;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound); // autosized input
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -132,7 +132,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     state->dataSize->TermUnitSizing(1).MaxHWVolFlow = 0.005;
 
     // Test #1 - Zone Equipment, no autosizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -143,7 +143,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -179,7 +179,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -196,7 +196,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -210,7 +210,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -224,7 +224,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -238,7 +238,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -253,7 +253,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -271,7 +271,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -286,7 +286,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -302,7 +302,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -333,7 +333,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -358,7 +358,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     state->dataSize->DataCapacityUsedForSizing = 5000.0;
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -386,7 +386,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc
index 44fe9e1e4ec..1825f134e69 100644
--- a/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc
@@ -79,7 +79,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // ZONE EQUIPMENT TESTING
     state->dataSize->CurZoneEqNum = 1;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
@@ -92,7 +92,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -137,7 +137,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -153,7 +153,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -166,7 +166,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -178,7 +178,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -193,7 +193,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -206,7 +206,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -219,7 +219,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -233,7 +233,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -247,7 +247,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -259,7 +259,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -276,7 +276,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -290,7 +290,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -302,7 +302,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -314,7 +314,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -327,7 +327,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -339,7 +339,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -354,7 +354,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -367,7 +367,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -380,7 +380,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -393,7 +393,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -405,7 +405,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -418,7 +418,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -436,7 +436,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -449,7 +449,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -462,7 +462,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -475,7 +475,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -487,7 +487,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -500,7 +500,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -514,7 +514,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -527,7 +527,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -540,7 +540,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -553,7 +553,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -565,7 +565,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -578,7 +578,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // start with an auto-sized value as the user input
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -590,7 +590,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     state->dataSize->ZoneEqSizing(1).AirVolFlow = 1.75;
     inputValue = DataSizing::AutoSize;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -601,7 +601,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // Test 37 - Zone Equipment, hard size with zone sizing run
     inputValue = 1.44;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -612,7 +612,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     inputValue = 1.44;
     state->dataSize->ZoneSizingRunDone = false;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -625,7 +625,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     inputValue = 1.44;
     state->dataSize->ZoneSizingRunDone = false;
     // do sizing
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -654,7 +654,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -683,7 +683,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -707,7 +707,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -726,7 +726,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -740,7 +740,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -755,7 +755,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -775,7 +775,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -789,7 +789,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -803,7 +803,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -818,7 +818,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -832,7 +832,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -848,7 +848,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -862,7 +862,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -877,7 +877,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -891,7 +891,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -905,7 +905,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -922,7 +922,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -945,7 +945,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*this->state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc
index 6ff4af9703b..1af003d26f9 100644
--- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc
@@ -83,7 +83,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     state->dataSize->CurTermUnitSizingNum = 1;
     state->dataSize->TermUnitSingDuct = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*state, inputValue, errorsFound);
@@ -96,7 +96,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -146,7 +146,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     // do sizing
     sizer.zoneSizingInput.allocate(1);
     sizer.zoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -161,7 +161,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -175,7 +175,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -188,7 +188,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -204,7 +204,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -220,7 +220,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -234,7 +234,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -247,7 +247,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = DataSizing::AutoSize;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -262,7 +262,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     inputValue = 1500.0;
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc
index 84b84b013b0..08e8faf1f5d 100644
--- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc
@@ -84,7 +84,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     state->dataSize->CurTermUnitSizingNum = 1;
     state->dataSize->TermUnitSingDuct = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
 
     // Test #1 - Zone Equipment, no autosizing
     sizedValue = sizer.size(*state, inputValue, errorsFound);
@@ -97,7 +97,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     has_eio_output(true);
     printFlag = true;
 
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -156,7 +156,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -174,7 +174,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // do sizing
     state->dataSize->ZoneSizingInput.allocate(1);
     state->dataSize->ZoneSizingInput(1).ZoneNum = 1;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_TRUE(errorsFound);
     EXPECT_TRUE(state->dataSize->DataErrorsFound);
@@ -209,7 +209,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_FALSE(sizer.wasAutoSized);
@@ -232,7 +232,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -252,7 +252,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -267,7 +267,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::ErrorType1, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -290,7 +290,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
 
     // do sizing
     sizer.wasAutoSized = false;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType);
     EXPECT_TRUE(sizer.wasAutoSized);
@@ -307,7 +307,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // do sizing
     sizer.wasAutoSized = false;
     printFlag = true;
-    sizer.initializeWithinEP(*this->state, HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater), "MyWaterCoil", printFlag, routineName);
+    sizer.initializeWithinEP(*this->state, HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater], "MyWaterCoil", printFlag, routineName);
     sizedValue = sizer.size(*state, inputValue, errorsFound);
     EXPECT_ENUM_EQ(AutoSizingResultType::NoError, sizer.errorType); // cumulative of previous calls
     EXPECT_FALSE(sizer.wasAutoSized);
diff --git a/tst/EnergyPlus/unit/DXCoils.unit.cc b/tst/EnergyPlus/unit/DXCoils.unit.cc
index a1f33c3dfbd..ac270cfeedf 100644
--- a/tst/EnergyPlus/unit/DXCoils.unit.cc
+++ b/tst/EnergyPlus/unit/DXCoils.unit.cc
@@ -214,10 +214,8 @@ TEST_F(EnergyPlusFixture, DXCoils_Test1)
 
     state->dataDXCoils->NumDXCoils = 2;
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
-    state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
-    state->dataDXCoils->DXCoil(1).DXCoilType = "Coil:Cooling:DX:MultiSpeed";
-    state->dataDXCoils->DXCoil(2).DXCoilType_Num = HVAC::CoilDX_MultiSpeedHeating;
-    state->dataDXCoils->DXCoil(2).DXCoilType = "Coil:Heating:DX:MultiSpeed";
+    state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingDXMultiSpeed;
+    state->dataDXCoils->DXCoil(2).coilType = HVAC::CoilType::HeatingDXMultiSpeed;
     state->dataDXCoils->DXCoil(1).MSRatedTotCap.allocate(2);
     state->dataDXCoils->DXCoil(2).MSRatedTotCap.allocate(2);
     state->dataDXCoils->DXCoil(2).CompanionUpstreamDXCoil = 1;
@@ -348,9 +346,8 @@ TEST_F(EnergyPlusFixture, DXCoils_Test2)
     DXCoilNum = 2;
     state->dataSize->UnitarySysEqSizing.allocate(1);
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
-    state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
-    state->dataDXCoils->DXCoil(2).DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
-    state->dataDXCoils->DXCoil(DXCoilNum).DXCoilType = "Coil:Heating:DX:SingleSpeed";
+    state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingDXSingleSpeed;
+    state->dataDXCoils->DXCoil(2).coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     state->dataDXCoils->DXCoil(2).CompanionUpstreamDXCoil = 1;
 
     state->dataDXCoils->DXCoilNumericFields.allocate(state->dataDXCoils->NumDXCoils);
@@ -453,8 +450,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedDefrostCOP)
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
     DXCoilData &Coil = state->dataDXCoils->DXCoil(DXCoilNum);
 
-    Coil.DXCoilType = "Coil:Heating:DX:MultiSpeed";
-    Coil.DXCoilType_Num = HVAC::CoilDX_MultiSpeedHeating;
+    Coil.coilType = HVAC::CoilType::HeatingDXMultiSpeed;
     Coil.availSched = Sched::GetScheduleAlwaysOn(*state);
 
     state->dataDXCoils->DXCoilNumericFields.allocate(state->dataDXCoils->NumDXCoils);
@@ -937,8 +933,7 @@ TEST_F(EnergyPlusFixture, TestSingleSpeedDefrostCOP)
     DXCoilData &Coil = state->dataDXCoils->DXCoil(DXCoilNum);
 
     Coil.Name = "DX Single Speed Heating Coil";
-    Coil.DXCoilType = "Coil:Heating:DX:SingleSpeed";
-    Coil.DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    Coil.coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     Coil.availSched = Sched::GetScheduleAlwaysOn(*state);
     state->dataLoopNodes->Node.allocate(1);
     Coil.AirOutNode = 1;
@@ -1120,20 +1115,20 @@ TEST_F(EnergyPlusFixture, TestCalcCBF)
 
     AirPressure = StdPressureSeaLevel;
     InletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(*state, InletDBTemp, InletWBTemp, AirPressure);
-    CBF_calculated = CalcCBF(*state, CoilType, CoilName, InletDBTemp, InletAirHumRat, TotalCap, AirVolFlowRate, SHR, true);
+    CBF_calculated = CalcCBF(*state, HVAC::CoilType::WaterHeatingDXWrapped, CoilName, InletDBTemp, InletAirHumRat, TotalCap, AirVolFlowRate, SHR, true);
     CBF_expected = 0.17268167698750708;
     EXPECT_NEAR(CBF_calculated, CBF_expected, 0.000000000000001);
 
     // push inlet condition towards saturation curve to test CBF calculation robustness
     InletWBTemp = 19.7; // 19.72 DB / 19.7 WB
     InletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(*state, InletDBTemp, InletWBTemp, AirPressure);
-    CBF_calculated = CalcCBF(*state, CoilType, CoilName, InletDBTemp, InletAirHumRat, TotalCap, AirVolFlowRate, SHR, true);
+    CBF_calculated = CalcCBF(*state, HVAC::CoilType::WaterHeatingDXWrapped, CoilName, InletDBTemp, InletAirHumRat, TotalCap, AirVolFlowRate, SHR, true);
     EXPECT_NEAR(CBF_calculated, 0.00020826, 0.0000001);
 
     InletDBTemp = 13.1;  // colder and much less likely inlet air temperature
     InletWBTemp = 13.08; // 13.1 DB / 13.08 WB - hard to find ADP (needed mod to CalcCBF function)
     InletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(*state, InletDBTemp, InletWBTemp, AirPressure);
-    CBF_calculated = CalcCBF(*state, CoilType, CoilName, InletDBTemp, InletAirHumRat, TotalCap, AirVolFlowRate, SHR, true);
+    CBF_calculated = CalcCBF(*state, HVAC::CoilType::WaterHeatingDXWrapped, CoilName, InletDBTemp, InletAirHumRat, TotalCap, AirVolFlowRate, SHR, true);
     EXPECT_NEAR(CBF_calculated, 0.0001572, 0.0000001);
 }
 
@@ -2116,43 +2111,43 @@ TEST_F(EnergyPlusFixture, TestReadingCoilCoolingHeatingDX)
     state->dataEnvrn->StdRhoAir = Psychrometrics::PsyRhoAirFnPbTdbW(*state, state->dataEnvrn->OutBaroPress, 20.0, 0.0);
 
     // Coil:Cooling:DX:SingleSpeed
-    EXPECT_EQ(state->dataDXCoils->DXCoil(1).DXCoilType_Num, HVAC::CoilDX_CoolingSingleSpeed);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(1).coilType, HVAC::CoilType::CoolingDXSingleSpeed);
     EXPECT_EQ("HEATERCAPCURVE", Curve::GetCurveName(*state, state->dataDXCoils->DXCoil(1).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:Cooling:DX:TwoStageWithHumidityControlMode
-    EXPECT_EQ(state->dataDXCoils->DXCoil(2).DXCoilType_Num, HVAC::CoilDX_CoolingTwoStageWHumControl);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(2).coilType, HVAC::CoilType::CoolingDXTwoStageWHumControl);
     EXPECT_EQ("HEATERCAPCURVE7", Curve::GetCurveName(*state, state->dataDXCoils->DXCoil(2).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:Heating:DX:SingleSpeed
-    EXPECT_EQ(state->dataDXCoils->DXCoil(3).DXCoilType_Num, HVAC::CoilDX_HeatingEmpirical);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(3).coilType, HVAC::CoilType::HeatingDXSingleSpeed);
     EXPECT_EQ("HEATERCAPCURVE2", Curve::GetCurveName(*state, state->dataDXCoils->DXCoil(3).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:WaterHeating:AirToWaterHeatPump:Pumped
-    EXPECT_EQ(state->dataDXCoils->DXCoil(4).DXCoilType_Num, HVAC::CoilDX_HeatPumpWaterHeaterPumped);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(4).coilType, HVAC::CoilType::WaterHeatingDXPumped);
     EXPECT_EQ("HEATERCAPCURVE9", Curve::GetCurveName(*state, state->dataDXCoils->DXCoil(4).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:WaterHeating:AirToWaterHeatPump:Wrapped
-    EXPECT_EQ(state->dataDXCoils->DXCoil(5).DXCoilType_Num, HVAC::CoilDX_HeatPumpWaterHeaterWrapped);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(5).coilType, HVAC::CoilType::WaterHeatingDXWrapped);
     EXPECT_EQ("HEATERCAPCURVE8", Curve::GetCurveName(*state, state->dataDXCoils->DXCoil(5).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:Cooling:DX:MultiSpeed
-    EXPECT_EQ(state->dataDXCoils->DXCoil(6).DXCoilType_Num, HVAC::CoilDX_MultiSpeedCooling);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(6).coilType, HVAC::CoilType::CoolingDXMultiSpeed);
     EXPECT_EQ("HEATERCAPCURVE3", Curve::GetCurveName(*state, state->dataDXCoils->DXCoil(6).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:Heating:DX:MultiSpeed
-    EXPECT_EQ(state->dataDXCoils->DXCoil(7).DXCoilType_Num, HVAC::CoilDX_MultiSpeedHeating);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(7).coilType, HVAC::CoilType::HeatingDXMultiSpeed);
     EXPECT_EQ("HEATERCAPCURVE4", Curve::GetCurveName(*state, state->dataDXCoils->DXCoil(7).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:Cooling:DX:VariableSpeed
-    EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).VSCoilType, HVAC::Coil_CoolingAirToAirVariableSpeed);
+    EXPECT_ENUM_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).coilType, HVAC::CoilType::CoolingDXVariableSpeed);
     EXPECT_EQ("HEATERCAPCURVE5", Curve::GetCurveName(*state, state->dataVariableSpeedCoils->VarSpeedCoil(1).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:Heating:DX:VariableSpeed
-    EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(2).VSCoilType, HVAC::Coil_HeatingAirToAirVariableSpeed);
+    EXPECT_ENUM_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(2).coilType, HVAC::CoilType::HeatingDXVariableSpeed);
     EXPECT_EQ("HEATERCAPCURVE6", Curve::GetCurveName(*state, state->dataVariableSpeedCoils->VarSpeedCoil(2).CrankcaseHeaterCapacityCurveIndex));
 
     // Coil:WaterHeating:AirToWaterHeatPump:VariableSpeed
-    EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(3).VSCoilType, HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed);
+    EXPECT_ENUM_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(3).coilType, HVAC::CoilType::WaterHeatingAWHPVariableSpeed);
     EXPECT_EQ("HEATERCAPCURVE10", Curve::GetCurveName(*state, state->dataVariableSpeedCoils->VarSpeedCoil(3).CrankcaseHeaterCapacityCurveIndex));
 
     state->dataEnvrn->OutDryBulbTemp = -5.0;
@@ -2679,7 +2674,7 @@ TEST_F(EnergyPlusFixture, DXCoil_ValidateADPFunction)
     std::string const CallingRoutine("DXCoil_ValidateADPFunction");
 
     Real64 CBF_calculated = CalcCBF(*state,
-                                    state->dataDXCoils->DXCoil(1).DXCoilType,
+                                    state->dataDXCoils->DXCoil(1).coilType,
                                     state->dataDXCoils->DXCoil(1).Name,
                                     RatedInletAirTemp,
                                     RatedInletAirHumRat,
@@ -2696,7 +2691,7 @@ TEST_F(EnergyPlusFixture, DXCoil_ValidateADPFunction)
 
     SizeDXCoil(*state, 1);
     CBF_calculated = CalcCBF(*state,
-                             state->dataDXCoils->DXCoil(1).DXCoilType,
+                             state->dataDXCoils->DXCoil(1).coilType,
                              state->dataDXCoils->DXCoil(1).Name,
                              RatedInletAirTemp,
                              RatedInletAirHumRat,
@@ -2713,7 +2708,7 @@ TEST_F(EnergyPlusFixture, DXCoil_ValidateADPFunction)
 
     SizeDXCoil(*state, 1);
     CBF_calculated = CalcCBF(*state,
-                             state->dataDXCoils->DXCoil(1).DXCoilType,
+                             state->dataDXCoils->DXCoil(1).coilType,
                              state->dataDXCoils->DXCoil(1).Name,
                              RatedInletAirTemp,
                              RatedInletAirHumRat,
@@ -3472,8 +3467,7 @@ TEST_F(SQLiteFixture, DXCoils_TestComponentSizingOutput_TwoSpeed)
     // OutputReportTabular::WriteEioTables();
 
     // Now check output tables / EIO
-    const std::string compType = state->dataDXCoils->DXCoil(1).DXCoilType;
-    EXPECT_EQ(compType, "Coil:Cooling:DX:TwoSpeed");
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(1).coilType, HVAC::CoilType::CoolingDXTwoSpeed);
     const std::string compName = state->dataDXCoils->DXCoil(1).Name;
     EXPECT_EQ(compName, "MAIN COOLING COIL 1");
 
@@ -3499,15 +3493,9 @@ TEST_F(SQLiteFixture, DXCoils_TestComponentSizingOutput_TwoSpeed)
 
     for (auto &testQuery : testQueries) {
 
-        std::string query("SELECT Value From ComponentSizes"
-                          "  WHERE CompType = '" +
-                          compType +
-                          "'"
-                          "  AND CompName = '" +
-                          compName +
-                          "'"
-                          "  AND Description = '" +
-                          testQuery.description + "'" + "  AND Units = '" + testQuery.units + "'");
+        std::string query =
+            format("SELECT Value From ComponentSizes WHERE CompType = '{}' AND CompName = '{}' AND Description = '{}' AND Units = '{}'",
+                   HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXTwoSpeed], compName, testQuery.description, testQuery.units);
 
         // execAndReturnFirstDouble returns -10000.0 if not found
         Real64 return_val = SQLiteFixture::execAndReturnFirstDouble(query);
@@ -3691,8 +3679,7 @@ TEST_F(SQLiteFixture, DXCoils_TestComponentSizingOutput_SingleSpeed)
     // OutputReportTabular::WriteEioTables();
 
     // Now check output tables / EIO
-    const std::string compType = state->dataDXCoils->DXCoil(1).DXCoilType;
-    EXPECT_EQ(compType, "Coil:Cooling:DX:SingleSpeed");
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(1).coilType, HVAC::CoilType::CoolingDXSingleSpeed);
     const std::string compName = state->dataDXCoils->DXCoil(1).Name;
     EXPECT_EQ(compName, "FURNACE ACDXCOIL 1");
 
@@ -3716,15 +3703,9 @@ TEST_F(SQLiteFixture, DXCoils_TestComponentSizingOutput_SingleSpeed)
 
     for (auto &testQuery : testQueries) {
 
-        std::string query("SELECT Value From ComponentSizes"
-                          "  WHERE CompType = '" +
-                          compType +
-                          "'"
-                          "  AND CompName = '" +
-                          compName +
-                          "'"
-                          "  AND Description = '" +
-                          testQuery.description + "'" + "  AND Units = '" + testQuery.units + "'");
+        std::string query =
+            format("SELECT Value From ComponentSizes WHERE CompType = '{}' AND CompName = '{}' AND Description = '{}' AND Units = '{}'",
+                   HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingDXSingleSpeed], compName, testQuery.description, testQuery.units);
 
         // execAndReturnFirstDouble returns -10000.0 if not found
         Real64 return_val = SQLiteFixture::execAndReturnFirstDouble(query);
@@ -4123,7 +4104,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedHeatingCoilSizingOutput)
     SetPredefinedTables(*state);
     // check multi-speed DX cooling coil
     EXPECT_EQ("ASHP CLG COIL", state->dataDXCoils->DXCoil(1).Name);
-    EXPECT_EQ("Coil:Cooling:DX:MultiSpeed", state->dataDXCoils->DXCoil(1).DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXMultiSpeed, state->dataDXCoils->DXCoil(1).coilType);
     SizeDXCoil(*state, 1);
     EXPECT_EQ(14067.4113682534, state->dataDXCoils->DXCoil(1).MSRatedTotCap(2));
     EXPECT_EQ(10128.5361851424, state->dataDXCoils->DXCoil(1).MSRatedTotCap(1));
@@ -4132,7 +4113,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedHeatingCoilSizingOutput)
 
     // check multi-speed DX heating coil
     EXPECT_EQ("ASHP HTG COIL", state->dataDXCoils->DXCoil(2).Name);
-    EXPECT_EQ("Coil:Heating:DX:MultiSpeed", state->dataDXCoils->DXCoil(2).DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingDXMultiSpeed, state->dataDXCoils->DXCoil(2).coilType);
     SizeDXCoil(*state, 2);
     EXPECT_EQ(14067.4113682534, state->dataDXCoils->DXCoil(2).MSRatedTotCap(2));
     EXPECT_EQ(10128.5361851424, state->dataDXCoils->DXCoil(2).MSRatedTotCap(1));
@@ -4343,7 +4324,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoolingCoilTabularReporting)
     EnergyPlus::OutputReportPredefined::SetPredefinedTables(*state);
     // check multi-speed DX cooling coil
     EXPECT_EQ("ASHP CLG COIL", state->dataDXCoils->DXCoil(1).Name);
-    EXPECT_EQ("Coil:Cooling:DX:MultiSpeed", state->dataDXCoils->DXCoil(1).DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXMultiSpeed, state->dataDXCoils->DXCoil(1).coilType);
     // coils are in an airloop
     state->dataSize->CurSysNum = 1;
     state->dataSize->UnitarySysEqSizing.allocate(state->dataSize->CurSysNum);
@@ -4763,7 +4744,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoilsAutoSizingOutput)
     SetPredefinedTables(*state);
     // check multi-speed DX cooling coil
     EXPECT_EQ("ASHP CLG COIL", state->dataDXCoils->DXCoil(1).Name);
-    EXPECT_EQ("Coil:Cooling:DX:MultiSpeed", state->dataDXCoils->DXCoil(1).DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXMultiSpeed, state->dataDXCoils->DXCoil(1).coilType);
 
     state->dataEnvrn->StdBaroPress = 101325.0;
     state->dataEnvrn->StdRhoAir = 1.2;
@@ -4822,7 +4803,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoilsAutoSizingOutput)
 
     // check multi-speed DX heating coil
     EXPECT_EQ("ASHP HTG COIL", state->dataDXCoils->DXCoil(2).Name);
-    EXPECT_EQ("Coil:Heating:DX:MultiSpeed", state->dataDXCoils->DXCoil(2).DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingDXMultiSpeed, state->dataDXCoils->DXCoil(2).coilType);
     // set companion dx cooling coil
     state->dataDXCoils->DXCoil(2).CompanionUpstreamDXCoil = 1;
     SizeDXCoil(*state, 2);
@@ -5050,7 +5031,7 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoolingCoilPartialAutoSizeOutput)
     SetPredefinedTables(*state);
     // check multi-speed DX cooling coil
     EXPECT_EQ("ASHP CLG COIL", state->dataDXCoils->DXCoil(1).Name);
-    EXPECT_EQ("Coil:Cooling:DX:MultiSpeed", state->dataDXCoils->DXCoil(1).DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXMultiSpeed, state->dataDXCoils->DXCoil(1).coilType);
 
     state->dataEnvrn->StdBaroPress = 101325.0;
     state->dataEnvrn->StdRhoAir = 1.2;
@@ -5116,10 +5097,8 @@ TEST_F(EnergyPlusFixture, DXCoils_GetDXCoilCapFTCurveIndexTest)
 
     state->dataDXCoils->NumDXCoils = 2;
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
-    state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
-    state->dataDXCoils->DXCoil(1).DXCoilType = "Coil:Cooling:DX:MultiSpeed";
-    state->dataDXCoils->DXCoil(2).DXCoilType_Num = HVAC::CoilDX_MultiSpeedHeating;
-    state->dataDXCoils->DXCoil(2).DXCoilType = "Coil:Heating:DX:MultiSpeed";
+    state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingDXMultiSpeed;
+    state->dataDXCoils->DXCoil(2).coilType = HVAC::CoilType::HeatingDXMultiSpeed;
 
     for (DXCoilNum = 1; DXCoilNum <= 2; ++DXCoilNum) {
         state->dataDXCoils->DXCoil(DXCoilNum).NumOfSpeeds = 2;
@@ -5193,8 +5172,8 @@ TEST_F(EnergyPlusFixture, DXCoils_GetDXCoilCapFTCurveIndexTest)
 
     // dx cooling coil
     int CoilIndex = 1;
-    EXPECT_EQ(state->dataDXCoils->DXCoil(CoilIndex).DXCoilType, "Coil:Cooling:DX:MultiSpeed");
-    DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(*state, CoilIndex, ErrorsFound);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(CoilIndex).coilType, HVAC::CoilType::CoolingDXMultiSpeed);
+    DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(*state, CoilIndex);
     EXPECT_EQ(2, DataTotCapCurveIndex);
     // evaluate dx cooling coil curves to show impacts of incorrect curve index
     Real64 TotCapTempModFac_lowestSpeed = CurveValue(*state, 1, 19.4, 30.0);
@@ -5210,8 +5189,8 @@ TEST_F(EnergyPlusFixture, DXCoils_GetDXCoilCapFTCurveIndexTest)
 
     // dx heating coil
     CoilIndex = 2;
-    EXPECT_EQ(state->dataDXCoils->DXCoil(CoilIndex).DXCoilType, "Coil:Heating:DX:MultiSpeed");
-    DataTotCapCurveIndex = DXCoils::GetDXCoilCapFTCurveIndex(*state, CoilIndex, ErrorsFound);
+    EXPECT_ENUM_EQ(state->dataDXCoils->DXCoil(CoilIndex).coilType, HVAC::CoilType::HeatingDXMultiSpeed);
+    DataTotCapCurveIndex = DXCoils::GetCoilCapFTCurve(*state, CoilIndex);
     EXPECT_EQ(4, DataTotCapCurveIndex);
     // evaluate dx heating coil curves to show impacts of incorrect curve index
     TotCapTempModFac_lowestSpeed = CurveValue(*state, 3, 5.0, 10.0);
@@ -5259,7 +5238,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedDXCoolingCoilOutputTest)
     auto &AirInletNode = state->dataLoopNodes->Node(1);
     auto &AirOutletNode = state->dataLoopNodes->Node(2);
     // set coil parameters
-    Coil.DXCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
+    Coil.coilType = HVAC::CoilType::CoolingDXSingleSpeed;
     Coil.availSched = Sched::GetScheduleAlwaysOn(*state);
     Coil.RatedTotCap(1) = 17580.0;
     Coil.RatedCOP(1) = 3.0;
@@ -5379,7 +5358,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedDXCoolingCoilOutputTest)
     // calculate condensate vol flow rate
     Real64 waterDensity = Psychrometrics::RhoH2O((Coil.InletAirTemp + Coil.OutletAirTemp) / 2.0);
     Real64 results_condenstateVdot = Coil.InletAirMassFlowRate * (Coil.InletAirHumRat - Coil.OutletAirHumRat) / waterDensity;
-    Coil.DXCoilType = "Coil:Cooling:DX:SingleSpeed";
+    Coil.coilType = HVAC::CoilType::CoolingDXSingleSpeed;
     ReportDXCoil(*state, DXCoilNum);
     // check condensate volume flow rate
     EXPECT_NEAR(results_condenstateVdot, Coil.CondensateVdot, 1.0E-11);
@@ -5408,8 +5387,7 @@ TEST_F(EnergyPlusFixture, MultiSpeedDXCoolingCoilOutputTest)
     auto &AirInletNode = state->dataLoopNodes->Node(1);
     auto &AirOutletNode = state->dataLoopNodes->Node(2);
 
-    Coil.DXCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
-    Coil.DXCoilType = "Coil:Cooling:DX:MultiSpeed";
+    Coil.coilType = HVAC::CoilType::CoolingDXMultiSpeed;
     Coil.availSched = Sched::GetScheduleAlwaysOn(*state);
 
     Coil.NumOfSpeeds = 2;
@@ -5714,8 +5692,7 @@ TEST_F(EnergyPlusFixture, TwoSpeedDXCoilStandardRatingsTest)
     // test 1: using internal static and fan pressure rise
     CalcTwoSpeedDXCoilStandardRating(*state, dXCoilIndex);
     EXPECT_EQ(coolcoilTwoSpeed.Name, "CCOOLING DX TWO SPEED");
-    EXPECT_EQ(coolcoilTwoSpeed.DXCoilType, "Coil:Cooling:DX:TwoSpeed");
-    EXPECT_EQ(coolcoilTwoSpeed.DXCoilType_Num, HVAC::CoilDX_CoolingTwoSpeed);
+    EXPECT_ENUM_EQ(coolcoilTwoSpeed.coilType, HVAC::CoilType::CoolingDXTwoSpeed);
     EXPECT_EQ(coolcoilTwoSpeed.InternalStaticPressureDrop, 400.0);
     EXPECT_TRUE(coolcoilTwoSpeed.RateWithInternalStaticAndFanObject);
     EXPECT_EQ("8.77", RetrievePreDefTableEntry(*state, state->dataOutRptPredefined->pdchDXCoolCoilEERIP, coolcoilTwoSpeed.Name));
@@ -5961,8 +5938,7 @@ TEST_F(EnergyPlusFixture, TwoSpeedDXCoilStandardRatings_Curve_Fix_Test)
 
     CalcTwoSpeedDXCoilStandardRating(*state, dXCoilIndex);
     EXPECT_EQ(coolcoilTwoSpeed.Name, "CCOOLING DX TWO SPEED");
-    EXPECT_EQ(coolcoilTwoSpeed.DXCoilType, "Coil:Cooling:DX:TwoSpeed");
-    EXPECT_EQ(coolcoilTwoSpeed.DXCoilType_Num, HVAC::CoilDX_CoolingTwoSpeed);
+    EXPECT_ENUM_EQ(coolcoilTwoSpeed.coilType, HVAC::CoilType::CoolingDXTwoSpeed);
     EXPECT_EQ(coolcoilTwoSpeed.InternalStaticPressureDrop, 400.0);
     EXPECT_TRUE(coolcoilTwoSpeed.RateWithInternalStaticAndFanObject);
     EXPECT_EQ("8.77", RetrievePreDefTableEntry(*state, state->dataOutRptPredefined->pdchDXCoolCoilEERIP, coolcoilTwoSpeed.Name));
@@ -7271,7 +7247,7 @@ TEST_F(EnergyPlusFixture, MultiSpeedDXHeatingCoilsHSPF2Test)
     auto thisHtgDXCoil = state->dataDXCoils->DXCoil(1);
     // check multi-speed DX heating coil
     EXPECT_EQ("ASHP HTG COIL", thisHtgDXCoil.Name);
-    EXPECT_EQ("Coil:Heating:DX:MultiSpeed", thisHtgDXCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingDXMultiSpeed, thisHtgDXCoil.coilType);
     EXPECT_EQ(-8.0, thisHtgDXCoil.MinOATCompressor);
     EXPECT_EQ(-6.0, thisHtgDXCoil.OATempCompressorOn);
     EXPECT_EQ(773.3, thisHtgDXCoil.MSFanPowerPerEvapAirFlowRate(1));
@@ -7531,7 +7507,7 @@ TEST_F(EnergyPlusFixture, MultiSpeedDXHeatingCoilsHSPF2Test1)
     auto thisHtgDXCoil = state->dataDXCoils->DXCoil(1);
     // check multi-speed DX heating coil
     EXPECT_EQ("ASHP HTG COIL", thisHtgDXCoil.Name);
-    EXPECT_EQ("Coil:Heating:DX:MultiSpeed", thisHtgDXCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingDXMultiSpeed, thisHtgDXCoil.coilType);
     EXPECT_EQ(-8.0, thisHtgDXCoil.MinOATCompressor);
     EXPECT_EQ(-6.0, thisHtgDXCoil.OATempCompressorOn);
     EXPECT_EQ(773.3, thisHtgDXCoil.MSFanPowerPerEvapAirFlowRate(1));
@@ -7793,7 +7769,7 @@ TEST_F(EnergyPlusFixture, MultiSpeedDXHeatingCoilsHSPF2Test2)
     auto thisHtgDXCoil = state->dataDXCoils->DXCoil(1);
     // check multi-speed DX heating coil
     EXPECT_EQ("ASHP HTG COIL", thisHtgDXCoil.Name);
-    EXPECT_EQ("Coil:Heating:DX:MultiSpeed", thisHtgDXCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingDXMultiSpeed, thisHtgDXCoil.coilType);
     EXPECT_EQ(-10.0, thisHtgDXCoil.MinOATCompressor);
     EXPECT_EQ(-8.0, thisHtgDXCoil.OATempCompressorOn);
     EXPECT_EQ(773.3, thisHtgDXCoil.MSFanPowerPerEvapAirFlowRate(1));
diff --git a/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc b/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc
index 385b7e2bfba..973798ed57f 100644
--- a/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc
+++ b/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc
@@ -5504,7 +5504,7 @@ TEST_F(EnergyPlusFixture, DesiccantDehum_RegenAirHeaterHWCoilSizingTest)
     EXPECT_EQ(1, state->dataDesiccantDehumidifiers->NumGenericDesicDehums);
     EXPECT_EQ("DESICCANT 1", state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).Name);
     EXPECT_EQ("DESICCANT REGEN COIL", state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).RegenCoilName);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).RegenCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).regenCoilType);
 
     CompName = state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).Name;
     CompIndex = state->dataDesiccantDehumidifiers->NumGenericDesicDehums;
@@ -6759,9 +6759,9 @@ TEST_F(EnergyPlusFixture, DesiccantDehum_VSCoolingCoilOnPrimaryAirSystemTest)
     EXPECT_EQ("DESICCANT 1", state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).Name);
     EXPECT_EQ("DESICCANT REGEN COIL", state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).RegenCoilName);
 
-    EXPECT_EQ(state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).coolingCoil_TypeNum, HVAC::Coil_CoolingAirToAirVariableSpeed);
+    EXPECT_ENUM_EQ(state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).coolCoilType, HVAC::CoilType::CoolingDXVariableSpeed);
 
-    EXPECT_ENUM_EQ(state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).CoilUpstreamOfProcessSide, Selection::Yes);
+    EXPECT_EQ(state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).CoilUpstreamOfProcessSide, true);
 
     CompName = state->dataDesiccantDehumidifiers->DesicDehum(DesicDehumNum).Name;
     CompIndex = state->dataDesiccantDehumidifiers->NumGenericDesicDehums;
diff --git a/tst/EnergyPlus/unit/FanCoilUnits.unit.cc b/tst/EnergyPlus/unit/FanCoilUnits.unit.cc
index 91c8c0c2f9e..df4b9891fa0 100644
--- a/tst/EnergyPlus/unit/FanCoilUnits.unit.cc
+++ b/tst/EnergyPlus/unit/FanCoilUnits.unit.cc
@@ -258,9 +258,9 @@ TEST_F(EnergyPlusFixture, MultiStage4PipeFanCoilHeatingTest)
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::MultiSpeedFan, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -578,9 +578,9 @@ TEST_F(EnergyPlusFixture, MultiStage4PipeFanCoilCoolingTest)
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::MultiSpeedFan, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -895,9 +895,9 @@ TEST_F(EnergyPlusFixture, ConstantFanVariableFlowFanCoilHeatingTest)
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::ConsFanVarFlow, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -1031,8 +1031,8 @@ TEST_F(EnergyPlusFixture, ConstantFanVariableFlowFanCoilHeatingTest)
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopNum = 1;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
-    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
-    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(2).WaterOutletNodeNum;
+    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNode = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
+    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNode = state->dataWaterCoils->WaterCoil(2).WaterOutletNodeNum;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.branchNum = 1;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.compNum = 1;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.branchNum = 1;
@@ -1293,9 +1293,9 @@ TEST_F(EnergyPlusFixture, ElectricCoilFanCoilHeatingTest)
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::ConsFanVarFlow, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingElectric, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 1;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -1402,8 +1402,8 @@ TEST_F(EnergyPlusFixture, ElectricCoilFanCoilHeatingTest)
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopNum = 0;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Invalid;
-    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNodeNum = 0;
-    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
+    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNode = 0;
+    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNode = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.branchNum = 1;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.compNum = 1;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.branchNum = 0;
@@ -1621,9 +1621,9 @@ TEST_F(EnergyPlusFixture, ConstantFanVariableFlowFanCoilCoolingTest)
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::ConsFanVarFlow, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -1759,8 +1759,8 @@ TEST_F(EnergyPlusFixture, ConstantFanVariableFlowFanCoilCoolingTest)
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopNum = 1;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
-    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
-    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(2).WaterOutletNodeNum;
+    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNode = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
+    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNode = state->dataWaterCoils->WaterCoil(2).WaterOutletNodeNum;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.branchNum = 1;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.compNum = 1;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.branchNum = 1;
@@ -1993,9 +1993,9 @@ TEST_F(EnergyPlusFixture, FanCoil_ASHRAE90VariableFan)
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::ASHRAE, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -2380,7 +2380,7 @@ TEST_F(EnergyPlusFixture, Test_TightenWaterFlowLimits)
     state->dataLoopNodes->Node(state->dataFanCoilUnits->FanCoil(FanCoilNum).AirInNode).MassFlowRateMax = 0.719999999;
     state->dataLoopNodes->Node(6).MassFlowRateMaxAvail = 0.72;
     state->dataLoopNodes->Node(5).MassFlowRateMaxAvail = 0.72;
-    state->dataFanCoilUnits->FanCoil(FanCoilNum).CCoilName_Index = 2;
+    state->dataFanCoilUnits->FanCoil(FanCoilNum).CoolCoilNum = 2;
     state->dataGlobal->BeginEnvrnFlag = true;
     state->dataEnvrn->DayOfYear_Schedule = 1;
     state->dataEnvrn->DayOfWeek = 2;
@@ -2716,9 +2716,9 @@ TEST_F(EnergyPlusFixture, FanCoil_CyclingFanMode)
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::CycFan, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -3158,9 +3158,9 @@ TEST_F(EnergyPlusFixture, FanCoil_FanSystemModelCyclingFanMode)
 
     EXPECT_ENUM_EQ(CCM::CycFan, thisFanCoil.CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", thisFanCoil.OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::SystemModel, (int)thisFanCoil.fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", thisFanCoil.HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::SystemModel, thisFanCoil.fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, thisFanCoil.heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -3556,9 +3556,9 @@ TEST_F(EnergyPlusFixture, FanCoil_ElecHeatCoilMultiSpeedFanCyclingFanMode)
     auto &thisFanCoil(state->dataFanCoilUnits->FanCoil(1));
     EXPECT_ENUM_EQ(CCM::MultiSpeedFan, thisFanCoil.CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", thisFanCoil.OAMixType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", thisFanCoil.HCoilType);
-    EXPECT_EQ((int)HVAC::FanType::SystemModel, (int)thisFanCoil.fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingElectric, thisFanCoil.heatCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::SystemModel, thisFanCoil.fanType);
 
     state->dataPlnt->TotNumLoops = 1;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -3922,9 +3922,9 @@ TEST_F(EnergyPlusFixture, FanCoil_ElecHeatCoilMultiSpeedFanContFanMode)
     auto &thisFanCoil(state->dataFanCoilUnits->FanCoil(1));
     EXPECT_ENUM_EQ(CCM::MultiSpeedFan, thisFanCoil.CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", thisFanCoil.OAMixType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", thisFanCoil.HCoilType);
-    EXPECT_EQ((int)HVAC::FanType::SystemModel, (int)thisFanCoil.fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingElectric, thisFanCoil.heatCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::SystemModel, thisFanCoil.fanType);
 
     state->dataPlnt->TotNumLoops = 1;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -4287,9 +4287,9 @@ TEST_F(EnergyPlusFixture, FanCoil_CalcFanCoilElecHeatCoilPLRResidual)
     auto &thisFanCoil(state->dataFanCoilUnits->FanCoil(1));
     EXPECT_ENUM_EQ(CCM::MultiSpeedFan, thisFanCoil.CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", thisFanCoil.OAMixType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", thisFanCoil.HCoilType);
-    EXPECT_EQ((int)HVAC::FanType::SystemModel, (int)thisFanCoil.fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingElectric, thisFanCoil.heatCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::SystemModel, thisFanCoil.fanType);
 
     state->dataPlnt->TotNumLoops = 1;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -4602,9 +4602,9 @@ TEST_F(EnergyPlusFixture, FanCoil_ElectricHeatingCoilASHRAE90VariableFan)
     auto &thisFanCoil(state->dataFanCoilUnits->FanCoil(1));
     EXPECT_ENUM_EQ(CCM::ASHRAE, thisFanCoil.CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", thisFanCoil.OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)thisFanCoil.fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", thisFanCoil.HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, thisFanCoil.fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingElectric, thisFanCoil.heatCoilType);
 
     state->dataPlnt->TotNumLoops = 1;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
diff --git a/tst/EnergyPlus/unit/FaultsManager.unit.cc b/tst/EnergyPlus/unit/FaultsManager.unit.cc
index 4475b368f35..d19b393a378 100644
--- a/tst/EnergyPlus/unit/FaultsManager.unit.cc
+++ b/tst/EnergyPlus/unit/FaultsManager.unit.cc
@@ -428,7 +428,7 @@ TEST_F(EnergyPlusFixture, FaultsManager_TemperatureSensorOffset_CoilSAT)
 
     // Check
     EXPECT_EQ(2.0, state->dataFaultsMgr->FaultsCoilSATSensor(1).Offset);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFaultsMgr->FaultsCoilSATSensor(1).CoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFaultsMgr->FaultsCoilSATSensor(1).coilType);
     EXPECT_TRUE(state->dataHVACControllers->ControllerProps(1).FaultyCoilSATFlag);
     EXPECT_EQ(1, state->dataHVACControllers->ControllerProps(1).FaultyCoilSATIndex);
 }
@@ -663,13 +663,13 @@ TEST_F(EnergyPlusFixture, FaultsManager_FoulingCoil_CoilNotFound)
         "   ** Warning ** ProcessScheduleInput: Schedule:Compact = AVAILSCHED",
         "   **   ~~~   ** Schedule Type Limits Name is empty.",
         "   **   ~~~   ** Schedule will not be validated.",
-        "   ** Severe  ** FaultModel:Fouling:Coil = \"FOULEDHEATINGCOIL\". Referenced Coil named \"NON EXISTENT COOLING COIL\" was not found.",
+        "   ** Severe  ** CheckAndReadFaults: FaultModel:Fouling:Coil = FOULEDHEATINGCOIL",
+        "   **   ~~~   ** Coil Name = NON EXISTENT COOLING COIL, item not found.", 
         "   **  Fatal  ** CheckAndReadFaults: Errors found in getting FaultModel input data. Preceding condition(s) cause termination.",
         "   ...Summary of Errors that led to program termination:",
         "   ..... Reference severe error count=1",
-        "   ..... Last severe error=FaultModel:Fouling:Coil = \"FOULEDHEATINGCOIL\". Referenced Coil named \"NON EXISTENT COOLING COIL\" was not "
-        "found.",
-    });
+        "   ..... Last severe error=CheckAndReadFaults: FaultModel:Fouling:Coil = FOULEDHEATINGCOIL"
+      });
 
     EXPECT_TRUE(compare_err_stream(error_string, true));
 }
@@ -880,10 +880,10 @@ TEST_F(EnergyPlusFixture, FaultsManager_FoulingCoil_AssignmentAndCalc)
         int FaultIndex = 1;
         EXPECT_EQ("AHU HW HEATING COIL", state->dataWaterCoils->WaterCoil(CoilNum).Name);
         EXPECT_NEAR(6.64, state->dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.0001);
-        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType);
+        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType);
 
-        EXPECT_EQ(CoilNum, state->dataFaultsMgr->FouledCoils(FaultIndex).FouledCoilNum);
-        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, state->dataFaultsMgr->FouledCoils(FaultIndex).FouledCoilType);
+        EXPECT_EQ(CoilNum, state->dataFaultsMgr->FouledCoils(FaultIndex).CoilNum);
+        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterSimpleHeating, state->dataFaultsMgr->FouledCoils(FaultIndex).coilPlantType);
 
         EXPECT_TRUE(state->dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag);
         EXPECT_EQ(FaultIndex, state->dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex);
@@ -907,10 +907,10 @@ TEST_F(EnergyPlusFixture, FaultsManager_FoulingCoil_AssignmentAndCalc)
         int CoilNum = 2;
         int FaultIndex = 2;
         EXPECT_EQ("AHU CHW COOLING COIL", state->dataWaterCoils->WaterCoil(CoilNum).Name);
-        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterCooling, state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType);
+        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterCooling, state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType);
 
-        EXPECT_EQ(CoilNum, state->dataFaultsMgr->FouledCoils(FaultIndex).FouledCoilNum);
-        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterCooling, state->dataFaultsMgr->FouledCoils(FaultIndex).FouledCoilType);
+        EXPECT_EQ(CoilNum, state->dataFaultsMgr->FouledCoils(FaultIndex).CoilNum);
+        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterCooling, state->dataFaultsMgr->FouledCoils(FaultIndex).coilPlantType);
 
         EXPECT_TRUE(state->dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag);
         EXPECT_EQ(FaultIndex, state->dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex);
@@ -938,7 +938,7 @@ TEST_F(EnergyPlusFixture, FaultsManager_FoulingCoil_AssignmentAndCalc)
     {
         int CoilNum = 3;
         EXPECT_EQ("AHU CHW COIL WITH NO FAULT", state->dataWaterCoils->WaterCoil(CoilNum).Name);
-        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterCooling, state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType);
+        EXPECT_ENUM_EQ(DataPlant::PlantEquipmentType::CoilWaterCooling, state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType);
 
         EXPECT_FALSE(state->dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag);
         EXPECT_EQ(0, state->dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex);
diff --git a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc
index fce3bdc4901..63a3854315c 100644
--- a/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc
+++ b/tst/EnergyPlus/unit/Fixtures/EnergyPlusFixture.cc
@@ -119,7 +119,6 @@ void EnergyPlusFixture::SetUp()
     state->dataUtilityRoutines->outputErrorHeader = false;
 
     state->init_constant_state(*state);
-    createCoilSelectionReportObj(*state); // So random
     state->dataEnvrn->StdRhoAir = 1.2;
 }
 
diff --git a/tst/EnergyPlus/unit/FluidCoolers.unit.cc b/tst/EnergyPlus/unit/FluidCoolers.unit.cc
index 929ad7c3d2c..72d7334312a 100644
--- a/tst/EnergyPlus/unit/FluidCoolers.unit.cc
+++ b/tst/EnergyPlus/unit/FluidCoolers.unit.cc
@@ -366,7 +366,7 @@ TEST_F(EnergyPlusFixture, FluidCooler_SizeWhenPlantSizingIndexIsZero)
     state->dataPlnt->PlantLoop.allocate(FluidCoolerNum);
     state->dataPlnt->PlantLoop(1).FluidName = "WATER";
     state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state);
-    // state->dataFluidCoolers->SimpleFluidCooler.allocate(FluidCoolerNum);
+
     state->dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).plantLoc.loopNum = 1;
     state->dataPlnt->PlantLoop(1).PlantSizNum = 0;
 
diff --git a/tst/EnergyPlus/unit/Furnaces.unit.cc b/tst/EnergyPlus/unit/Furnaces.unit.cc
index df77516cd12..7a157898b78 100644
--- a/tst/EnergyPlus/unit/Furnaces.unit.cc
+++ b/tst/EnergyPlus/unit/Furnaces.unit.cc
@@ -66,6 +66,7 @@
 #include <EnergyPlus/IOFiles.hh>
 #include <EnergyPlus/OutputProcessor.hh>
 #include <EnergyPlus/Plant/DataPlant.hh>
+#include <EnergyPlus/ReportCoilSelection.hh>
 #include <EnergyPlus/ScheduleManager.hh>
 #include <EnergyPlus/SimulationManager.hh>
 #include <EnergyPlus/UtilityRoutines.hh>
@@ -96,51 +97,51 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     state->dataHVACGlobal->MSHPMassFlowRateLow = 0.0;
     state->dataHVACGlobal->MSHPMassFlowRateHigh = 0.0;
 
-    state->dataFurnaces->Furnace.allocate(1);
+    state->dataFurnaces->Furnaces.allocate(1);
 
-    state->dataFurnaces->Furnace(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatCool;
+    state->dataFurnaces->Furnaces(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatCool;
 
-    state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum = 1;
-    state->dataFurnaces->Furnace(FurnaceNum).FurnaceOutletNodeNum = 2;
-    state->dataFurnaces->Furnace(FurnaceNum).ControlZoneNum = 1;
+    state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode = 1;
+    state->dataFurnaces->Furnaces(FurnaceNum).FurnaceOutletNode = 2;
+    state->dataFurnaces->Furnaces(FurnaceNum).ControlZoneNum = 1;
 
-    state->dataFurnaces->Furnace(FurnaceNum).MaxHeatAirMassFlow = 0.5;
-    state->dataFurnaces->Furnace(FurnaceNum).MaxCoolAirMassFlow = 0.75;
+    state->dataFurnaces->Furnaces(FurnaceNum).MaxHeatAirMassFlow = 0.5;
+    state->dataFurnaces->Furnaces(FurnaceNum).MaxCoolAirMassFlow = 0.75;
 
-    state->dataFurnaces->Furnace(FurnaceNum).HeatMassFlowRate.allocate(3);
-    state->dataFurnaces->Furnace(FurnaceNum).CoolMassFlowRate.allocate(3);
-    state->dataFurnaces->Furnace(FurnaceNum).MSHeatingSpeedRatio.allocate(3);
-    state->dataFurnaces->Furnace(FurnaceNum).MSCoolingSpeedRatio.allocate(3);
+    state->dataFurnaces->Furnaces(FurnaceNum).HeatMassFlowRate.allocate(3);
+    state->dataFurnaces->Furnaces(FurnaceNum).CoolMassFlowRate.allocate(3);
+    state->dataFurnaces->Furnaces(FurnaceNum).MSHeatingSpeedRatio.allocate(3);
+    state->dataFurnaces->Furnaces(FurnaceNum).MSCoolingSpeedRatio.allocate(3);
 
-    state->dataFurnaces->Furnace(FurnaceNum).LastMode = Furnaces::ModeOfOperation::HeatingMode;
-    state->dataFurnaces->Furnace(FurnaceNum).IdleMassFlowRate = 0.2;
-    state->dataFurnaces->Furnace(FurnaceNum).IdleSpeedRatio = 0.2;
-    state->dataFurnaces->Furnace(FurnaceNum).fanAvailSched = Sched::GetScheduleAlwaysOn(*state);
-    state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum = 1;
+    state->dataFurnaces->Furnaces(FurnaceNum).LastMode = Furnaces::ModeOfOperation::HeatingMode;
+    state->dataFurnaces->Furnaces(FurnaceNum).IdleMassFlowRate = 0.2;
+    state->dataFurnaces->Furnaces(FurnaceNum).IdleSpeedRatio = 0.2;
+    state->dataFurnaces->Furnaces(FurnaceNum).fanAvailSched = Sched::GetScheduleAlwaysOn(*state);
+    state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode = 1;
 
-    state->dataFurnaces->Furnace(FurnaceNum).HeatMassFlowRate(1) = 0.25;
-    state->dataFurnaces->Furnace(FurnaceNum).MSHeatingSpeedRatio(1) = 0.25;
-    state->dataFurnaces->Furnace(FurnaceNum).HeatMassFlowRate(2) = 0.5;
-    state->dataFurnaces->Furnace(FurnaceNum).MSHeatingSpeedRatio(2) = 0.5;
-    state->dataFurnaces->Furnace(FurnaceNum).HeatMassFlowRate(3) = 1.0;
-    state->dataFurnaces->Furnace(FurnaceNum).MSHeatingSpeedRatio(3) = 1.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).HeatMassFlowRate(1) = 0.25;
+    state->dataFurnaces->Furnaces(FurnaceNum).MSHeatingSpeedRatio(1) = 0.25;
+    state->dataFurnaces->Furnaces(FurnaceNum).HeatMassFlowRate(2) = 0.5;
+    state->dataFurnaces->Furnaces(FurnaceNum).MSHeatingSpeedRatio(2) = 0.5;
+    state->dataFurnaces->Furnaces(FurnaceNum).HeatMassFlowRate(3) = 1.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).MSHeatingSpeedRatio(3) = 1.0;
 
-    state->dataFurnaces->Furnace(FurnaceNum).CoolMassFlowRate(1) = 0.3;
-    state->dataFurnaces->Furnace(FurnaceNum).MSCoolingSpeedRatio(1) = 0.3;
-    state->dataFurnaces->Furnace(FurnaceNum).CoolMassFlowRate(2) = 0.6;
-    state->dataFurnaces->Furnace(FurnaceNum).MSCoolingSpeedRatio(2) = 0.6;
-    state->dataFurnaces->Furnace(FurnaceNum).CoolMassFlowRate(3) = 1.2;
-    state->dataFurnaces->Furnace(FurnaceNum).MSCoolingSpeedRatio(3) = 1.2;
+    state->dataFurnaces->Furnaces(FurnaceNum).CoolMassFlowRate(1) = 0.3;
+    state->dataFurnaces->Furnaces(FurnaceNum).MSCoolingSpeedRatio(1) = 0.3;
+    state->dataFurnaces->Furnaces(FurnaceNum).CoolMassFlowRate(2) = 0.6;
+    state->dataFurnaces->Furnaces(FurnaceNum).MSCoolingSpeedRatio(2) = 0.6;
+    state->dataFurnaces->Furnaces(FurnaceNum).CoolMassFlowRate(3) = 1.2;
+    state->dataFurnaces->Furnaces(FurnaceNum).MSCoolingSpeedRatio(3) = 1.2;
 
     state->dataZoneEnergyDemand->CurDeadBandOrSetback(1) = false;
 
-    state->dataFurnaces->Furnace(FurnaceNum).fanOp = HVAC::FanOp::Cycling;
+    state->dataFurnaces->Furnaces(FurnaceNum).fanOp = HVAC::FanOp::Cycling;
     // heating air flow at various speeds
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 0;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 0;
     //	Furnace( FurnaceNum ).SchedPtr = 0; // denotes incorrect schedule name in Furnace input ( returns 0.0 )
-    state->dataFurnaces->Furnace(FurnaceNum).availSched =
+    state->dataFurnaces->Furnaces(FurnaceNum).availSched =
         Sched::GetScheduleAlwaysOn(*state); // denotes missing schedule name in Furnace input ( returns 1.0 )
     state->dataFurnaces->HeatingLoad = true;
     state->dataFurnaces->CoolingLoad = false;
@@ -149,10 +150,10 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(0.5, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(0.5, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(0.5, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 1;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 1;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 0;
     state->dataFurnaces->HeatingLoad = true;
     state->dataFurnaces->CoolingLoad = false;
     SetVSHPAirFlow(*state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
@@ -161,10 +162,10 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(0.25, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(0.25, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(0.25, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 2;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 2;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 0;
     state->dataFurnaces->HeatingLoad = true;
     state->dataFurnaces->CoolingLoad = false;
     SetVSHPAirFlow(*state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
@@ -173,10 +174,10 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(0.5, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(0.5, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(0.5, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 3;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 3;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 0;
     state->dataFurnaces->HeatingLoad = true;
     state->dataFurnaces->CoolingLoad = false;
     SetVSHPAirFlow(*state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
@@ -185,7 +186,7 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(1.0, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(1.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(1.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
     // Test availability manager signal
     state->dataHVACGlobal->TurnFansOff = true;
@@ -196,11 +197,11 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(1.0, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(0.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(0.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(0.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
     state->dataHVACGlobal->TurnFansOff = false;
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 0;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 1;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 1;
     state->dataFurnaces->HeatingLoad = false;
     state->dataFurnaces->CoolingLoad = true;
     SetVSHPAirFlow(*state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
@@ -209,10 +210,10 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(0.3, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(0.3, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(0.3, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 0;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 2;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 2;
     state->dataFurnaces->HeatingLoad = false;
     state->dataFurnaces->CoolingLoad = true;
     SetVSHPAirFlow(*state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
@@ -221,10 +222,10 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(0.6, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(0.6, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(0.6, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 0;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 3;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 3;
     state->dataFurnaces->HeatingLoad = false;
     state->dataFurnaces->CoolingLoad = true;
     SetVSHPAirFlow(*state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
@@ -233,13 +234,13 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.0, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(1.2, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(1.2, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(1.2, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
     // constant fan mode should drop to idle flow rate
-    state->dataFurnaces->Furnace(FurnaceNum).fanOp = HVAC::FanOp::Continuous;
+    state->dataFurnaces->Furnaces(FurnaceNum).fanOp = HVAC::FanOp::Continuous;
 
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedHeating = 0;
-    state->dataFurnaces->Furnace(FurnaceNum).NumOfSpeedCooling = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedHeating = 0;
+    state->dataFurnaces->Furnaces(FurnaceNum).NumOfSpeedCooling = 0;
     state->dataFurnaces->HeatingLoad = true;
     state->dataFurnaces->CoolingLoad = false;
     SetVSHPAirFlow(*state, FurnaceNum, PartLoadRatio, OnOffAirFlowRatio);
@@ -248,7 +249,7 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     EXPECT_DOUBLE_EQ(0.2, state->dataFurnaces->CompOffMassFlow);
     EXPECT_DOUBLE_EQ(0.5, state->dataFurnaces->CompOnMassFlow);
     EXPECT_DOUBLE_EQ(1.0, OnOffAirFlowRatio);
-    EXPECT_DOUBLE_EQ(0.5, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(FurnaceNum).FurnaceInletNodeNum).MassFlowRate);
+    EXPECT_DOUBLE_EQ(0.5, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(FurnaceNum).FurnaceInletNode).MassFlowRate);
 
     bool firstHVACIteration = true;
     HVAC::CompressorOp compressorOp = HVAC::CompressorOp::On;
@@ -260,57 +261,64 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     bool hXUnitOn = false;
 
     state->dataEnvrn->OutDryBulbTemp = 35.0;
-    state->dataFurnaces->Furnace(FurnaceNum).WatertoAirHPType = WAHPCoilType::Simple; // switch to water to air heat pump
-    state->dataFurnaces->Furnace(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir;
-    state->dataFurnaces->Furnace(FurnaceNum).NodeNumOfControlledZone = 1; // use inlet node as surrogate for zone node number
+    state->dataFurnaces->Furnaces(FurnaceNum).WatertoAirHPType = WAHPCoilType::Simple; // switch to water to air heat pump
+    state->dataFurnaces->Furnaces(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatPump_WaterToAir;
+    state->dataFurnaces->Furnaces(FurnaceNum).NodeNumOfControlledZone = 1; // use inlet node as surrogate for zone node number
 
     state->dataFurnaces->HeatingLoad = false;
     state->dataFurnaces->CoolingLoad = false;
 
     CalcNewZoneHeatCoolFlowRates(
         *state, FurnaceNum, firstHVACIteration, compressorOp, zoneLoad, moistureLoad, heatCoilLoad, reheatCoilLoad, onOffAirFlowRatio, hXUnitOn);
-    EXPECT_EQ(state->dataFurnaces->Furnace(1).MdotFurnace, 0.5); // CompOnMassFlow rate
+    EXPECT_EQ(state->dataFurnaces->Furnaces(1).MdotFurnace, 0.5); // CompOnMassFlow rate
     EXPECT_EQ(state->dataLoopNodes->Node(1).MassFlowRate, 0.5);  // furnace inlet node mass flow rate
-    EXPECT_EQ(state->dataFurnaces->Furnace(1).CoolPartLoadRatio, 0.0);
-    EXPECT_EQ(state->dataFurnaces->Furnace(1).HeatPartLoadRatio, 0.0);
+    EXPECT_EQ(state->dataFurnaces->Furnaces(1).CoolPartLoadRatio, 0.0);
+    EXPECT_EQ(state->dataFurnaces->Furnaces(1).HeatPartLoadRatio, 0.0);
 
     firstHVACIteration = false; // now the coils will be called
-    state->dataFurnaces->Furnace(FurnaceNum).CoolingCoilIndex = 1;
-    state->dataFurnaces->Furnace(FurnaceNum).HeatingCoilIndex = 2;
+    state->dataFurnaces->Furnaces(FurnaceNum).CoolCoilNum = 1;
+    state->dataFurnaces->Furnaces(FurnaceNum).HeatCoilNum = 2;
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP.allocate(2);
     state->dataWaterToAirHeatPumpSimple->NumWatertoAirHPs = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).Name = "WATERCOOLINGCOIL";
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPType = WaterToAirHeatPumpSimple::WatertoAirHP::Cooling;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).Name = "WATERHEATINGCOIL";
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPType = WaterToAirHeatPumpSimple::WatertoAirHP::Heating;
+    auto &wahp1 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1);
+    wahp1.Name = "WATERCOOLINGCOIL";
+    wahp1.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
+    wahp1.coilType = HVAC::CoilType::CoolingWAHPSimple;
+    wahp1.coilReportNum = ReportCoilSelection::getReportIndex(*state, wahp1.Name, wahp1.coilType);
+
+    auto &wahp2 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2);
+    wahp2.Name = "WATERHEATINGCOIL";
+    wahp2.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
+    wahp2.coilType = HVAC::CoilType::HeatingWAHPSimple;
+    wahp2.coilReportNum = ReportCoilSelection::getReportIndex(*state, wahp2.Name, wahp2.coilType);
+
     state->dataWaterToAirHeatPumpSimple->SimpleHPTimeStepFlag.allocate(2);
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).AirInletNodeNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).AirOutletNodeNum = 3;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterInletNodeNum = 5;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterOutletNodeNum = 6;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loopNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.branchNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.compNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolTotal = 30000.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCOPCoolAtRatedCdts = 3.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapHeat = 30000.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCOPHeatAtRatedCdts = 3.0;
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).AirInletNodeNum = 3;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).AirOutletNodeNum = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterInletNodeNum = 7;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterOutletNodeNum = 8;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loopNum = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.branchNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.compNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapCoolTotal = 30000.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCOPCoolAtRatedCdts = 3.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeat = 30000.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCOPHeatAtRatedCdts = 3.0;
+    
+    wahp1.AirInletNodeNum = 1;
+    wahp1.AirOutletNodeNum = 3;
+    wahp1.WaterInletNodeNum = 5;
+    wahp1.WaterOutletNodeNum = 6;
+    wahp1.plantLoc.loopNum = 1;
+    wahp1.plantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
+    wahp1.plantLoc.branchNum = 1;
+    wahp1.plantLoc.compNum = 1;
+    wahp1.RatedCapCoolTotal = 30000.0;
+    wahp1.RatedCOPCoolAtRatedCdts = 3.0;
+    wahp1.RatedCapHeat = 30000.0;
+    wahp1.RatedCOPHeatAtRatedCdts = 3.0;
+
+    wahp2.AirInletNodeNum = 3;
+    wahp2.AirOutletNodeNum = 2;
+    wahp2.WaterInletNodeNum = 7;
+    wahp2.WaterOutletNodeNum = 8;
+    wahp2.plantLoc.loopNum = 2;
+    wahp2.plantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
+    wahp2.plantLoc.branchNum = 1;
+    wahp2.plantLoc.compNum = 1;
+    wahp2.RatedCapCoolTotal = 30000.0;
+    wahp2.RatedCOPCoolAtRatedCdts = 3.0;
+    wahp2.RatedCapHeat = 30000.0;
+    wahp2.RatedCOPHeatAtRatedCdts = 3.0;
 
     // set up plant loop
     state->dataPlnt->TotNumLoops = 2;
@@ -344,16 +352,16 @@ TEST_F(EnergyPlusFixture, SetVSHPAirFlowTest_VSFurnaceFlowTest)
     state->dataWaterToAirHeatPumpSimple->GetCoilsInputFlag = false; // turn off water source coil GetInput
     CalcNewZoneHeatCoolFlowRates(
         *state, FurnaceNum, firstHVACIteration, compressorOp, zoneLoad, moistureLoad, heatCoilLoad, reheatCoilLoad, onOffAirFlowRatio, hXUnitOn);
-    EXPECT_EQ(state->dataFurnaces->Furnace(1).MdotFurnace, 0.2); // flow rate is at idle speed flow rate
+    EXPECT_EQ(state->dataFurnaces->Furnaces(1).MdotFurnace, 0.2); // flow rate is at idle speed flow rate
     EXPECT_EQ(state->dataLoopNodes->Node(1).MassFlowRate, 0.2);  // furnace inlet node mass flow rate is at idle speed flow rate
-    EXPECT_EQ(state->dataFurnaces->Furnace(1).CoolPartLoadRatio, 0.0);
-    EXPECT_EQ(state->dataFurnaces->Furnace(1).HeatPartLoadRatio, 0.0);
+    EXPECT_EQ(state->dataFurnaces->Furnaces(1).CoolPartLoadRatio, 0.0);
+    EXPECT_EQ(state->dataFurnaces->Furnaces(1).HeatPartLoadRatio, 0.0);
 
-    state->dataFurnaces->Furnace(1).HeatPartLoadRatio = 1.0;
+    state->dataFurnaces->Furnaces(1).HeatPartLoadRatio = 1.0;
     state->dataFurnaces->HeatingLoad = true;
     CalcNewZoneHeatCoolFlowRates(
         *state, FurnaceNum, firstHVACIteration, compressorOp, zoneLoad, moistureLoad, heatCoilLoad, reheatCoilLoad, onOffAirFlowRatio, hXUnitOn);
-    EXPECT_EQ(state->dataFurnaces->Furnace(1).HeatPartLoadRatio, 1.0);
+    EXPECT_EQ(state->dataFurnaces->Furnaces(1).HeatPartLoadRatio, 1.0);
 }
 
 TEST_F(EnergyPlusFixture, FurnaceTest_PartLoadRatioTest)
@@ -365,16 +373,16 @@ TEST_F(EnergyPlusFixture, FurnaceTest_PartLoadRatioTest)
     int FurnaceNum;
 
     FurnaceNum = 1;
-    state->dataFurnaces->Furnace.allocate(1);
-    state->dataFurnaces->Furnace(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatPump_AirToAir;
+    state->dataFurnaces->Furnaces.allocate(1);
+    state->dataFurnaces->Furnaces(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatPump_AirToAir;
 
     state->dataFurnaces->CompOnMassFlow = 2.0;
     state->dataFurnaces->CompOffMassFlow = 0.0;
-    state->dataFurnaces->Furnace(FurnaceNum).fanOp = HVAC::FanOp::Cycling;
-    state->dataFurnaces->Furnace(FurnaceNum).MdotFurnace = 2.0;
-    state->dataFurnaces->Furnace(FurnaceNum).DesignMassFlowRate = 2.2;
-    state->dataFurnaces->Furnace(FurnaceNum).HeatPartLoadRatio = 1.0;
-    state->dataFurnaces->Furnace(FurnaceNum).CoolPartLoadRatio = 0.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).fanOp = HVAC::FanOp::Cycling;
+    state->dataFurnaces->Furnaces(FurnaceNum).MdotFurnace = 2.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).DesignMassFlowRate = 2.2;
+    state->dataFurnaces->Furnaces(FurnaceNum).HeatPartLoadRatio = 1.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).CoolPartLoadRatio = 0.0;
 
     state->afn->simulation_control.type = AirflowNetwork::ControlType::MultizoneWithDistribution;
     state->afn->distribution_simulated = true;
@@ -385,17 +393,17 @@ TEST_F(EnergyPlusFixture, FurnaceTest_PartLoadRatioTest)
     EXPECT_EQ((int)HVAC::FanOp::Cycling, (int)state->dataAirLoop->AirLoopAFNInfo(1).LoopFanOperationMode);
     EXPECT_EQ(1.0, state->dataAirLoop->AirLoopAFNInfo(1).LoopOnOffFanPartLoadRatio);
 
-    state->dataFurnaces->Furnace(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatCool;
-    state->dataFurnaces->Furnace(FurnaceNum).HeatPartLoadRatio = 0.0;
-    state->dataFurnaces->Furnace(FurnaceNum).CoolPartLoadRatio = 0.0;
-    state->dataFurnaces->Furnace(FurnaceNum).MaxCoolAirMassFlow = 2.2;
-    state->dataFurnaces->Furnace(FurnaceNum).MaxHeatAirMassFlow = 2.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).type = HVAC::UnitarySysType::Unitary_HeatCool;
+    state->dataFurnaces->Furnaces(FurnaceNum).HeatPartLoadRatio = 0.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).CoolPartLoadRatio = 0.0;
+    state->dataFurnaces->Furnaces(FurnaceNum).MaxCoolAirMassFlow = 2.2;
+    state->dataFurnaces->Furnaces(FurnaceNum).MaxHeatAirMassFlow = 2.0;
 
     ReportFurnace(*state, FurnaceNum, 1);
 
     EXPECT_EQ(1.0, state->dataAirLoop->AirLoopAFNInfo(1).LoopOnOffFanPartLoadRatio);
 
-    state->dataFurnaces->Furnace.deallocate();
+    state->dataFurnaces->Furnaces.deallocate();
 }
 
 TEST_F(EnergyPlusFixture, UnitaryHeatPumpAirToAir_MaxSuppAirTempTest)
@@ -1194,45 +1202,48 @@ TEST_F(EnergyPlusFixture, UnitaryHeatPumpAirToAir_MaxSuppAirTempTest)
     // OutputProcessor::TimeValue.allocate(2);
     ManageSimulation(*state);
     // check the design max air outlet temperature
-    EXPECT_DOUBLE_EQ(45.0, state->dataFurnaces->Furnace(1).DesignMaxOutletTemp);
+    EXPECT_DOUBLE_EQ(45.0, state->dataFurnaces->Furnaces(1).DesignMaxOutletTemp);
 
     state->dataZoneEnergyDemand->ZoneSysEnergyDemand(1).SequencedOutputRequiredToCoolingSP(1) = 25000.0;
     state->dataZoneEnergyDemand->ZoneSysEnergyDemand(1).SequencedOutputRequiredToHeatingSP(1) = 25000.0;
-    SimFurnace(*state, state->dataFurnaces->Furnace(1).Name, FirstHVACIteration, AirLoopNum, CompIndex);
+    SimFurnace(*state, state->dataFurnaces->Furnaces(1).Name, FirstHVACIteration, AirLoopNum, CompIndex);
     // check the heating mode is On
     EXPECT_TRUE(state->dataFurnaces->HeatingLoad);
     // check the cooling mode is Off
     EXPECT_FALSE(state->dataFurnaces->CoolingLoad);
     // check if the air-to-air heat pump outlet temperature is capped at 45.0C
-    EXPECT_NEAR(45.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(1).FurnaceOutletNodeNum).Temp, 0.000001);
-    EXPECT_NEAR(0.3326, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(1).FurnaceOutletNodeNum).MassFlowRate, 0.0001);
-    EXPECT_NEAR(121.06458, state->dataFurnaces->Furnace(1).SensibleLoadMet, 0.001);
+    EXPECT_NEAR(45.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(1).FurnaceOutletNode).Temp, 0.000001);
+    EXPECT_NEAR(0.3326, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(1).FurnaceOutletNode).MassFlowRate, 0.0001);
+    EXPECT_NEAR(121.06458, state->dataFurnaces->Furnaces(1).SensibleLoadMet, 0.001);
 
     // Test airflow when fan is forced off
     state->dataHVACGlobal->TurnFansOn = false;
     state->dataHVACGlobal->TurnFansOff = true;
-    SimFurnace(*state, state->dataFurnaces->Furnace(1).Name, FirstHVACIteration, AirLoopNum, CompIndex);
-    EXPECT_NEAR(0.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnace(1).FurnaceOutletNodeNum).MassFlowRate, 0.000001);
-    EXPECT_NEAR(0.0, state->dataFurnaces->Furnace(1).SensibleLoadMet, 0.001);
+    SimFurnace(*state, state->dataFurnaces->Furnaces(1).Name, FirstHVACIteration, AirLoopNum, CompIndex);
+    EXPECT_NEAR(0.0, state->dataLoopNodes->Node(state->dataFurnaces->Furnaces(1).FurnaceOutletNode).MassFlowRate, 0.000001);
+    EXPECT_NEAR(0.0, state->dataFurnaces->Furnaces(1).SensibleLoadMet, 0.001);
 }
 
 TEST_F(EnergyPlusFixture, Furnaces_SetMinOATCompressor)
 {
-    state->dataFurnaces->Furnace.allocate(1);
-    state->dataFurnaces->Furnace(1).CoolingCoilIndex = 1;
-    state->dataFurnaces->Furnace(1).HeatingCoilIndex = 2;
+    state->dataFurnaces->Furnaces.allocate(1);
+    auto &furnace = state->dataFurnaces->Furnaces(1);
+    furnace.CoolCoilNum = 1;
+    furnace.HeatCoilNum = 2;
+    state->dataVariableSpeedCoils->NumVarSpeedCoils = 2;
     state->dataVariableSpeedCoils->VarSpeedCoil.allocate(2);
     state->dataVariableSpeedCoils->GetCoilsInputFlag = false;
     state->dataVariableSpeedCoils->VarSpeedCoil(1).MinOATCompressor = 30.0;
     state->dataVariableSpeedCoils->VarSpeedCoil(2).MinOATCompressor = 30.0;
+    state->dataDXCoils->NumDXCoils = 2;
     state->dataDXCoils->DXCoil.allocate(2);
     state->dataDXCoils->GetCoilsInputFlag = false;
     state->dataDXCoils->DXCoil(1).MinOATCompressor = 30.0;
     state->dataDXCoils->DXCoil(2).MinOATCompressor = 30.0;
 
-    state->dataHVACAssistedCC->HXAssistedCoil.allocate(1);
-    state->dataHVACAssistedCC->HXAssistedCoil(1).CoolingCoilType = "COIL:COOLING:DX";
-    state->dataHVACAssistedCC->HXAssistedCoil(1).CoolingCoilName = "Dummy_Name";
+    state->dataHVACAssistedCC->HXAssistedCoils.allocate(1);
+    state->dataHVACAssistedCC->HXAssistedCoils(1).coolCoilType = HVAC::CoilType::CoolingDX;
+    state->dataHVACAssistedCC->HXAssistedCoils(1).CoolCoilName = "Dummy_Name";
 
     state->dataCoilCoolingDX->coilCoolingDXGetInputFlag = false;
     CoilCoolingDX thisCoil;
@@ -1244,46 +1255,53 @@ TEST_F(EnergyPlusFixture, Furnaces_SetMinOATCompressor)
     bool ErrFound = false;
 
     // Test HXAsssisted type with new coil
-    state->dataFurnaces->Furnace(1).CoolingCoilType_Num = HVAC::CoilDX_CoolingHXAssisted;
+    furnace.coolCoilType = HVAC::CoilType::CoolingDXHXAssisted;
+    furnace.childCoolCoilName = HXAssistCoil::GetCoilChildCoilName(*state, furnace.CoolCoilNum);
+    furnace.childCoolCoilType = HXAssistCoil::GetCoilChildCoilType(*state, furnace.CoolCoilNum);
+    furnace.childCoolCoilNum = HXAssistCoil::GetCoilChildCoilIndex(*state, furnace.CoolCoilNum);
+
     SetMinOATCompressor(*state, FurnaceNum, cCurModObj, ErrFound);
     EXPECT_FALSE(ErrFound);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorCooling, 0.0, 1e-6);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorHeating, -1000.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorCooling, 0.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorHeating, -1000.0, 1e-6);
     // reset once as test
-    state->dataFurnaces->Furnace(1).MinOATCompressorCooling = -999.0;
-    state->dataFurnaces->Furnace(1).MinOATCompressorHeating = -999.0;
+    furnace.MinOATCompressorCooling = -999.0;
+    furnace.MinOATCompressorHeating = -999.0;
 
     // Check that each coil type returns correctly
-    state->dataFurnaces->Furnace(1).CoolingCoilType_Num = HVAC::Coil_CoolingAirToAirVariableSpeed;
-    state->dataFurnaces->Furnace(1).HeatingCoilType_Num = HVAC::Coil_HeatingElectric;
+    furnace.coolCoilType = HVAC::CoilType::CoolingDXVariableSpeed;
+    furnace.childCoolCoilType = HVAC::CoilType::Invalid;
+    furnace.childCoolCoilName = "";
+    furnace.childCoolCoilNum = 0;
+    furnace.heatCoilType = HVAC::CoilType::HeatingElectric;
     // Each test should return 30 for cooling coil (limited) and -1000 for heating coil (no limit)
     SetMinOATCompressor(*state, FurnaceNum, cCurModObj, ErrFound);
     EXPECT_FALSE(ErrFound);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorCooling, 30.0, 1e-6);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorHeating, -1000.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorCooling, 30.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorHeating, -1000.0, 1e-6);
     // reset once as test
-    state->dataFurnaces->Furnace(1).MinOATCompressorCooling = -999.0;
-    state->dataFurnaces->Furnace(1).MinOATCompressorHeating = -999.0;
+    furnace.MinOATCompressorCooling = -999.0;
+    furnace.MinOATCompressorHeating = -999.0;
 
-    state->dataFurnaces->Furnace(1).CoolingCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
+    furnace.coolCoilType = HVAC::CoilType::CoolingDXSingleSpeed;
     SetMinOATCompressor(*state, FurnaceNum, cCurModObj, ErrFound);
     EXPECT_FALSE(ErrFound);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorCooling, 30.0, 1e-6);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorHeating, -1000.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorCooling, 30.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorHeating, -1000.0, 1e-6);
 
     // check heating coil types
     // should return 30 in each case since cooling and heating coil now have limit
-    state->dataFurnaces->Furnace(1).HeatingCoilType_Num = HVAC::Coil_HeatingAirToAirVariableSpeed;
+    furnace.heatCoilType = HVAC::CoilType::HeatingDXVariableSpeed;
     SetMinOATCompressor(*state, FurnaceNum, cCurModObj, ErrFound);
     EXPECT_FALSE(ErrFound);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorCooling, 30.0, 1e-6); // same as above
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorHeating, 30.0, 1e-6); // now returns 30
+    EXPECT_NEAR(furnace.MinOATCompressorCooling, 30.0, 1e-6); // same as above
+    EXPECT_NEAR(furnace.MinOATCompressorHeating, 30.0, 1e-6); // now returns 30
 
-    state->dataFurnaces->Furnace(1).HeatingCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    furnace.heatCoilType = HVAC::CoilType::HeatingDXSingleSpeed;
     SetMinOATCompressor(*state, FurnaceNum, cCurModObj, ErrFound);
     EXPECT_FALSE(ErrFound);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorCooling, 30.0, 1e-6);
-    EXPECT_NEAR(state->dataFurnaces->Furnace(1).MinOATCompressorHeating, 30.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorCooling, 30.0, 1e-6);
+    EXPECT_NEAR(furnace.MinOATCompressorHeating, 30.0, 1e-6);
 }
 
 } // namespace EnergyPlus
diff --git a/tst/EnergyPlus/unit/HVACControllers.unit.cc b/tst/EnergyPlus/unit/HVACControllers.unit.cc
index 8194208298a..0bfc2c70413 100644
--- a/tst/EnergyPlus/unit/HVACControllers.unit.cc
+++ b/tst/EnergyPlus/unit/HVACControllers.unit.cc
@@ -238,23 +238,26 @@ TEST_F(EnergyPlusFixture, HVACControllers_TestTempAndHumidityRatioCtrlVarType)
     state->dataAirLoop->AirToZoneNodeInfo(1).ZoneEquipSupplyNodeNum(1) = 4;
     state->dataConvergeParams->AirLoopConvergence.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).NumBranches = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).NumControllers = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex(1) = 0;
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerName.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerName(1) = "CW COIL CONTROLLER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControlConverged.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNumIn = 4;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNumOut = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalNodes = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalComponents = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNum.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNum(1) = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "CHILLED WATER COIL";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::WaterCoil_Cooling;
+    auto &airSys = state->dataAirSystemsData->PrimaryAirSystems(1);
+    airSys.NumBranches = 1;
+    airSys.NumControllers = 1;
+    airSys.ControllerIndex.allocate(1);
+    airSys.ControllerIndex(1) = 0;
+    airSys.ControllerName.allocate(1);
+    airSys.ControllerName(1) = "CW COIL CONTROLLER";
+    airSys.ControlConverged.allocate(1);
+    airSys.Branch.allocate(1);
+    airSys.Branch(1).NodeNumIn = 4;
+    airSys.Branch(1).NodeNumOut = 1;
+    airSys.Branch(1).TotalNodes = 1;
+    airSys.Branch(1).TotalComponents = 1;
+    airSys.Branch(1).NodeNum.allocate(1);
+    airSys.Branch(1).NodeNum(1) = 1;
+    airSys.Branch(1).Comp.allocate(1);
+    airSys.Branch(1).Comp(1).Name = "CHILLED WATER COIL";
+    airSys.Branch(1).Comp(1).compType = SimAirServingZones::CompType::WaterCoil_Cooling;
+    airSys.Branch(1).Comp(1).CompIndex = WaterCoils::GetCoilIndex(*state, airSys.Branch(1).Comp(1).Name);
+    
     state->dataPlnt->PlantLoop.allocate(1);
     state->dataPlnt->TotNumLoops = 1;
 
@@ -273,8 +276,8 @@ TEST_F(EnergyPlusFixture, HVACControllers_TestTempAndHumidityRatioCtrlVarType)
     SimAirServingZones::SimAirLoops(*state, true, SimZoneEquipment);
 
     // after controllers are simulated, AirLoopControllerIndex = index to this controller on this air loop (e.g., n of num contollers on air loop)
-    ASSERT_EQ(1, state->dataAirSystemsData->PrimaryAirSystems(1).NumControllers);
-    ASSERT_EQ(1, state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex(1));
+    ASSERT_EQ(1, airSys.NumControllers);
+    ASSERT_EQ(1, airSys.ControllerIndex(1));
     ASSERT_EQ(1, state->dataHVACControllers->ControllerProps(1).AirLoopControllerIndex);
 }
 
@@ -419,32 +422,34 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnPrimaryLoopCheckTest)
     GetControllerInput(*state);
 
     ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).Name, "CHILLED WATER COIL");
-    ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).WaterCoilType, DataPlant::PlantEquipmentType::CoilWaterCooling);
+    ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).coilPlantType, DataPlant::PlantEquipmentType::CoilWaterCooling);
 
     OutputReportPredefined::SetPredefinedTables(*state);
     state->dataSimAirServingZones->GetAirLoopInputFlag = false;
     state->dataHVACGlobal->NumPrimaryAirSys = 1;
     state->dataAirSystemsData->PrimaryAirSystems.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).NumBranches = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).NumControllers = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex(1) = 0;
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerName.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerName(1) = "CW COIL CONTROLLER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControlConverged.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNumIn = 4;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNumOut = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalNodes = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalComponents = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNum.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNum(1) = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = state->dataWaterCoils->WaterCoil(1).Name;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::WaterCoil_Cooling;
+    auto &airSys = state->dataAirSystemsData->PrimaryAirSystems(1);
+    airSys.NumBranches = 1;
+    airSys.NumControllers = 1;
+    airSys.ControllerIndex.allocate(1);
+    airSys.ControllerIndex(1) = 0;
+    airSys.ControllerName.allocate(1);
+    airSys.ControllerName(1) = "CW COIL CONTROLLER";
+    airSys.ControlConverged.allocate(1);
+    airSys.Branch.allocate(1);
+    airSys.Branch(1).NodeNumIn = 4;
+    airSys.Branch(1).NodeNumOut = 1;
+    airSys.Branch(1).TotalNodes = 1;
+    airSys.Branch(1).TotalComponents = 1;
+    airSys.Branch(1).NodeNum.allocate(1);
+    airSys.Branch(1).NodeNum(1) = 1;
+    airSys.Branch(1).Comp.allocate(1);
+    airSys.Branch(1).Comp(1).Name = state->dataWaterCoils->WaterCoil(1).Name;
+    airSys.Branch(1).Comp(1).compType = SimAirServingZones::CompType::WaterCoil_Cooling;
+    airSys.Branch(1).Comp(1).CompIndex = WaterCoils::GetCoilIndex(*state, airSys.Branch(1).Comp(1).Name);
 
     bool WaterCoilOnAirLoop = true;
-    std::string CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWater); //"Coil:Cooling:Water";
+    HVAC::CoilType coilType = HVAC::CoilType::CoolingWater; //"Coil:Cooling:Water";
     std::string CompName = "CHILLED WATER COIL";
     SimAirServingZones::CompType CoilTypeNum = SimAirServingZones::CompType::WaterCoil_Cooling;
 
@@ -460,7 +465,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnPrimaryLoopCheckTest)
     EXPECT_FALSE(WaterCoilOnAirLoop);
 
     WaterCoilOnAirLoop = true;
-    SimAirServingZones::CheckWaterCoilIsOnAirLoop(*state, CoilTypeNum, CompType, CompName, WaterCoilOnAirLoop);
+    SimAirServingZones::CheckWaterCoilIsOnAirLoop(*state, CoilTypeNum, coilType, CompName, WaterCoilOnAirLoop);
     EXPECT_TRUE(WaterCoilOnAirLoop);
 
     // now test a different water coil type
@@ -513,7 +518,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnOutsideAirSystemCheckTest)
     GetControllerInput(*state);
 
     ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).Name, "OA PREHEAT HW COIL");
-    ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).WaterCoilType, DataPlant::PlantEquipmentType::CoilWaterSimpleHeating);
+    ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).coilPlantType, DataPlant::PlantEquipmentType::CoilWaterSimpleHeating);
 
     OutputReportPredefined::SetPredefinedTables(*state);
     state->dataSimAirServingZones->GetAirLoopInputFlag = false;
@@ -526,14 +531,14 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnOutsideAirSystemCheckTest)
     state->dataAirLoop->OutsideAirSys(1).ControllerName(1) = "OA CONTROLLER 1";
     state->dataAirLoop->OutsideAirSys(1).NumComponents = 2;
     state->dataAirLoop->OutsideAirSys(1).ComponentType.allocate(2);
-    state->dataAirLoop->OutsideAirSys(1).ComponentType(1) = HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater);
+    state->dataAirLoop->OutsideAirSys(1).ComponentType(1) = HVAC::coilTypeNames[(int)HVAC::CoilType::HeatingWater];
     state->dataAirLoop->OutsideAirSys(1).ComponentType(2) = "OutdoorAir:Mixer";
     state->dataAirLoop->OutsideAirSys(1).ComponentName.allocate(2);
     state->dataAirLoop->OutsideAirSys(1).ComponentName(1) = state->dataWaterCoils->WaterCoil(1).Name;
     state->dataAirLoop->OutsideAirSys(1).ComponentName(2) = "OAMixer";
     state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum.allocate(2);
     state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum(1) = SimAirServingZones::CompType::WaterCoil_SimpleHeat;
-    state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum(2) = SimAirServingZones::CompType::OAMixer_Num;
+    state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum(2) = SimAirServingZones::CompType::OAMixer;
 
     state->dataMixedAir->OAMixer.allocate(1);
     state->dataMixedAir->OAMixer(1).Name = "OAMixer";
@@ -550,7 +555,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnOutsideAirSystemCheckTest)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "AirLoopHVAC:OutdoorAirSystem";
 
     bool WaterCoilOnAirLoop = true;
-    std::string CompType = HVAC::cAllCoilTypes(HVAC::Coil_HeatingWater);
+    HVAC::CoilType coilType = HVAC::CoilType::HeatingWater;
     std::string CompName = state->dataWaterCoils->WaterCoil(1).Name;
     SimAirServingZones::CompType CoilTypeNum = SimAirServingZones::CompType::WaterCoil_SimpleHeat;
 
@@ -562,7 +567,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnOutsideAirSystemCheckTest)
     EXPECT_TRUE(WaterCoilOnAirLoop);
 
     WaterCoilOnAirLoop = false;
-    SimAirServingZones::CheckWaterCoilIsOnAirLoop(*state, CoilTypeNum, CompType, CompName, WaterCoilOnAirLoop);
+    SimAirServingZones::CheckWaterCoilIsOnAirLoop(*state, CoilTypeNum, coilType, CompName, WaterCoilOnAirLoop);
     EXPECT_TRUE(WaterCoilOnAirLoop);
 
     // test a different water coil type
@@ -646,7 +651,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_CoilSystemCoolingWaterOnOutsideAirSyst
     GetControllerInput(*state);
 
     ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).Name, "DETAILED PRE COOLING COIL");
-    ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).WaterCoilType, DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling);
+    ASSERT_EQ(state->dataWaterCoils->WaterCoil(1).coilPlantType, DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling);
 
     OutputReportPredefined::SetPredefinedTables(*state);
     state->dataSimAirServingZones->GetAirLoopInputFlag = false;
@@ -659,14 +664,14 @@ TEST_F(EnergyPlusFixture, HVACControllers_CoilSystemCoolingWaterOnOutsideAirSyst
     state->dataAirLoop->OutsideAirSys(1).ControllerName(1) = "OA CONTROLLER 1";
     state->dataAirLoop->OutsideAirSys(1).NumComponents = 2;
     state->dataAirLoop->OutsideAirSys(1).ComponentType.allocate(2);
-    state->dataAirLoop->OutsideAirSys(1).ComponentType(1) = HVAC::cAllCoilTypes(HVAC::CoilWater_CoolingHXAssisted);
+    state->dataAirLoop->OutsideAirSys(1).ComponentType(1) = HVAC::coilTypeNames[(int)HVAC::CoilType::CoolingWaterHXAssisted];
     state->dataAirLoop->OutsideAirSys(1).ComponentType(2) = "OutdoorAir:Mixer";
     state->dataAirLoop->OutsideAirSys(1).ComponentName.allocate(2);
     state->dataAirLoop->OutsideAirSys(1).ComponentName(1) = "HXAssisting Cooling Coil";
     state->dataAirLoop->OutsideAirSys(1).ComponentName(2) = "OAMixer";
     state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum.allocate(2);
     state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum(1) = SimAirServingZones::CompType::WaterCoil_CoolingHXAsst;
-    state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum(2) = SimAirServingZones::CompType::OAMixer_Num;
+    state->dataAirLoop->OutsideAirSys(1).ComponentTypeEnum(2) = SimAirServingZones::CompType::OAMixer;
 
     state->dataMixedAir->OAMixer.allocate(1);
     state->dataMixedAir->OAMixer(1).Name = "OAMixer";
@@ -683,7 +688,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_CoilSystemCoolingWaterOnOutsideAirSyst
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "AirLoopHVAC:OutdoorAirSystem";
 
     bool WaterCoilOnAirLoop = true;
-    std::string CompType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingWaterDetailed);
+    HVAC::CoilType coilType = HVAC::CoilType::CoolingWaterDetailed;
     std::string CompName = state->dataWaterCoils->WaterCoil(1).Name;
     SimAirServingZones::CompType CoilTypeNum = SimAirServingZones::CompType::WaterCoil_DetailedCool;
 
@@ -699,7 +704,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_CoilSystemCoolingWaterOnOutsideAirSyst
     EXPECT_TRUE(WaterCoilOnAirLoop);
 
     WaterCoilOnAirLoop = false;
-    SimAirServingZones::CheckWaterCoilIsOnAirLoop(*state, CoilTypeNum, CompType, CompName, WaterCoilOnAirLoop);
+    SimAirServingZones::CheckWaterCoilIsOnAirLoop(*state, CoilTypeNum, coilType, CompName, WaterCoilOnAirLoop);
     EXPECT_TRUE(WaterCoilOnAirLoop);
 }
 TEST_F(EnergyPlusFixture, HVACControllers_CheckTempAndHumRatCtrl)
@@ -952,23 +957,26 @@ TEST_F(EnergyPlusFixture, HVACControllers_MaxFlowZero)
     state->dataAirLoop->AirToZoneNodeInfo(1).ZoneEquipSupplyNodeNum(1) = 4;
     state->dataConvergeParams->AirLoopConvergence.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).NumBranches = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).NumControllers = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex(1) = 0;
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerName.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControllerName(1) = "CW COIL CONTROLLER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).ControlConverged.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNumIn = 4;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNumOut = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalNodes = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalComponents = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNum.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).NodeNum(1) = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "CHILLED WATER COIL";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::WaterCoil_Cooling;
+    auto &airSys = state->dataAirSystemsData->PrimaryAirSystems(1);
+    airSys.NumBranches = 1;
+    airSys.NumControllers = 1;
+    airSys.ControllerIndex.allocate(1);
+    airSys.ControllerIndex(1) = 0;
+    airSys.ControllerName.allocate(1);
+    airSys.ControllerName(1) = "CW COIL CONTROLLER";
+    airSys.ControlConverged.allocate(1);
+    airSys.Branch.allocate(1);
+    airSys.Branch(1).NodeNumIn = 4;
+    airSys.Branch(1).NodeNumOut = 1;
+    airSys.Branch(1).TotalNodes = 1;
+    airSys.Branch(1).TotalComponents = 1;
+    airSys.Branch(1).NodeNum.allocate(1);
+    airSys.Branch(1).NodeNum(1) = 1;
+    airSys.Branch(1).Comp.allocate(1);
+    airSys.Branch(1).Comp(1).Name = "CHILLED WATER COIL";
+    airSys.Branch(1).Comp(1).compType = SimAirServingZones::CompType::WaterCoil_Cooling;
+    airSys.Branch(1).Comp(1).CompIndex = WaterCoils::GetCoilIndex(*state, airSys.Branch(1).Comp(1).Name);
+    
     state->dataPlnt->PlantLoop.allocate(1);
     state->dataPlnt->TotNumLoops = 1;
     state->dataPlnt->PlantLoop(1).Name = "CHW LOOP";
@@ -1011,8 +1019,8 @@ TEST_F(EnergyPlusFixture, HVACControllers_MaxFlowZero)
     SimAirServingZones::SimAirLoops(*state, true, SimZoneEquipment);
 
     // after controllers are simulated, AirLoopControllerIndex = index to this controller on this air loop (e.g., n of num contollers on air loop)
-    ASSERT_EQ(1, state->dataAirSystemsData->PrimaryAirSystems(1).NumControllers);
-    ASSERT_EQ(1, state->dataAirSystemsData->PrimaryAirSystems(1).ControllerIndex(1));
+    ASSERT_EQ(1, airSys.NumControllers);
+    ASSERT_EQ(1, airSys.ControllerIndex(1));
     ASSERT_EQ(1, state->dataHVACControllers->ControllerProps(1).AirLoopControllerIndex);
 
     // This should have been autosized to zero
diff --git a/tst/EnergyPlus/unit/HVACDXHeatPumpSystem.unit.cc b/tst/EnergyPlus/unit/HVACDXHeatPumpSystem.unit.cc
index ecdd70287a0..93b63bd0698 100644
--- a/tst/EnergyPlus/unit/HVACDXHeatPumpSystem.unit.cc
+++ b/tst/EnergyPlus/unit/HVACDXHeatPumpSystem.unit.cc
@@ -113,7 +113,7 @@ TEST_F(EnergyPlusFixture, ExerciseHVACDXHeatPumpSystem)
     state->dataDXCoils->DXCoil(1).availSched = Sched::GetScheduleAlwaysOn(*state);
     state->dataDXCoils->DXCoil(1).AirInNode = 1;
     state->dataDXCoils->DXCoil(1).AirOutNode = 2;
-    state->dataDXCoils->DXCoil(1).DXCoilType = "COIL:HEATING:DX:SINGLESPEED";
+    state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     state->dataDXCoils->DXCoil(1).RatedTotCap(1) = 1;
     state->dataDXCoils->DXCoil(1).RatedCOP(1) = 1;
     state->dataDXCoils->DXCoil(1).CCapFFlow(1) = 1;
@@ -135,7 +135,7 @@ TEST_F(EnergyPlusFixture, ExerciseHVACDXHeatPumpSystem)
     state->dataDXCoils->DXCoilNumericFields.allocate(1);
     state->dataDXCoils->DXCoilNumericFields(1).PerfMode.allocate(1);
     state->dataDXCoils->DXCoilNumericFields(1).PerfMode(1).FieldNames.allocate(4);
-    state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::HeatingDXSingleSpeed;
 
     // manually add a curve
     auto *curve = Curve::AddCurve(*state, "Curve1");
diff --git a/tst/EnergyPlus/unit/HVACDXSystem.unit.cc b/tst/EnergyPlus/unit/HVACDXSystem.unit.cc
index 15a67a1d6ae..d997632ecb2 100644
--- a/tst/EnergyPlus/unit/HVACDXSystem.unit.cc
+++ b/tst/EnergyPlus/unit/HVACDXSystem.unit.cc
@@ -436,7 +436,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_DOASDXCoilTest)
     EXPECT_EQ(thisSys->Name, "DX COOLING COIL SYSTEM");
     EXPECT_FALSE(thisSys->m_ISHundredPercentDOASDXCoil);
     EXPECT_EQ(thisSys->UnitType, "CoilSystem:Cooling:DX");
-    EXPECT_EQ(thisSys->m_CoolingCoilType_Num, HVAC::Coil_CoolingAirToAirVariableSpeed);
+    EXPECT_ENUM_EQ(thisSys->m_coolCoilType, HVAC::CoilType::CoolingDXVariableSpeed);
 }
 
 TEST_F(EnergyPlusFixture, VariableSpeedCoils_RHControl)
@@ -577,7 +577,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_RHControl)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalComponents = 1;
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = compName;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::DXSystem;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::DXSystem;
     OutputReportPredefined::SetPredefinedTables(*state);
     Sched::GetSchedule(*state, "AVAILSCHED")->currentVal = 1.0; // Enable schedule without calling schedule manager
 
@@ -591,12 +591,13 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_RHControl)
     UnitarySystems::UnitarySys::factory(*state, HVAC::UnitarySysType::Unitary_AnyCoilType, compName, zoneEquipment, 0);
     UnitarySystems::UnitarySys *thisSys = &state->dataUnitarySystems->unitarySys[0];
     // call again to get the rest of the input when sysNum > -1
+    // I'm sorry, why is this necessary? There is literally nothing between the factory call and this call.
     UnitarySystems::UnitarySys::getUnitarySystemInput(*state, compName, false, 0);
 
     EXPECT_EQ(thisSys->Name, "DX COOLING COIL SYSTEM");
     EXPECT_FALSE(thisSys->m_ISHundredPercentDOASDXCoil);
     EXPECT_EQ(thisSys->UnitType, "CoilSystem:Cooling:DX");
-    EXPECT_EQ(thisSys->m_CoolingCoilType_Num, HVAC::Coil_CoolingAirToAirVariableSpeed);
+    EXPECT_ENUM_EQ(thisSys->m_coolCoilType, HVAC::CoilType::CoolingDXVariableSpeed);
     EXPECT_EQ(2, thisSys->CoolCtrlNode);
 
     // set up outdoor environment
@@ -776,7 +777,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_LatentDegradation_Test)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalComponents = 1;
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = compName;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::DXSystem;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::DXSystem;
     OutputReportPredefined::SetPredefinedTables(*state);
     Sched::GetSchedule(*state, "AVAILSCHED")->currentVal = 1.0; // Enable schedule without calling schedule manager
 
@@ -1051,7 +1052,7 @@ TEST_F(EnergyPlusFixture, NewDXCoilModel_RHControl)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalComponents = 1;
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = compName;
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::DXSystem;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::DXSystem;
     OutputReportPredefined::SetPredefinedTables(*state);
     Sched::GetSchedule(*state, "AVAILSCHED")->currentVal = 1.0; // Enable schedule without calling schedule manager
 
@@ -1071,7 +1072,7 @@ TEST_F(EnergyPlusFixture, NewDXCoilModel_RHControl)
     EXPECT_EQ(thisSys->Name, "DX COOLING COIL SYSTEM");
     EXPECT_FALSE(thisSys->m_ISHundredPercentDOASDXCoil);
     EXPECT_EQ(thisSys->UnitType, "CoilSystem:Cooling:DX");
-    EXPECT_EQ(thisSys->m_CoolingCoilType_Num, HVAC::CoilDX_Cooling);
+    EXPECT_ENUM_EQ(thisSys->m_coolCoilType, HVAC::CoilType::CoolingDX);
     EXPECT_EQ(2, thisSys->CoolCtrlNode);
 
     // set up outdoor environment
diff --git a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc
index e098d1f4f3e..5b3b326ae86 100644
--- a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc
+++ b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc
@@ -1463,8 +1463,8 @@ TEST_F(EnergyPlusFixture, HVACMultiSpeedHeatPump_HeatRecoveryTest)
     state->dataHVACMultiSpdHP->MSHeatPump.allocate(1);
     int HeatRecInNode(1);
     int HeatRecOutNode(2);
-    state->dataHVACMultiSpdHP->MSHeatPump(1).HeatRecInletNodeNum = HeatRecInNode;
-    state->dataHVACMultiSpdHP->MSHeatPump(1).HeatRecOutletNodeNum = HeatRecOutNode;
+    state->dataHVACMultiSpdHP->MSHeatPump(1).HeatRecFluidInletNode = HeatRecInNode;
+    state->dataHVACMultiSpdHP->MSHeatPump(1).HeatRecFluidOutletNode = HeatRecOutNode;
     state->dataHVACMultiSpdHP->MSHeatPump(1).MaxHeatRecOutletTemp = 80;
     state->dataHVACMultiSpdHP->MSHeatPump(1).HRPlantLoc.loopNum = 1; // index to plant
     state->dataLoopNodes->Node(HeatRecInNode).Temp = 50.0;
diff --git a/tst/EnergyPlus/unit/HVACStandaloneERV.unit.cc b/tst/EnergyPlus/unit/HVACStandaloneERV.unit.cc
index 17783ed0999..9c8bb5716bb 100644
--- a/tst/EnergyPlus/unit/HVACStandaloneERV.unit.cc
+++ b/tst/EnergyPlus/unit/HVACStandaloneERV.unit.cc
@@ -255,7 +255,7 @@ TEST_F(EnergyPlusFixture, HVACStandAloneERV_Test2)
     erv.ExhaustAirFanName = state->dataFans->fans(2)->Name;
     erv.ExhaustAirFanIndex = 2;
     erv.hxType = HVAC::HXType::AirToAir_Generic;
-    erv.HeatExchangerName = "ERV Heat Exchanger";
+    erv.hxName = "ERV Heat Exchanger";
     erv.AirVolFlowPerFloorArea = 0.01;
     erv.AirVolFlowPerOccupant = 0.0;
     erv.HighRHOAFlowRatio = 1.2;
diff --git a/tst/EnergyPlus/unit/HVACUnitaryBypassVAV.unit.cc b/tst/EnergyPlus/unit/HVACUnitaryBypassVAV.unit.cc
index a24b0edbef6..85aecf9e7b1 100644
--- a/tst/EnergyPlus/unit/HVACUnitaryBypassVAV.unit.cc
+++ b/tst/EnergyPlus/unit/HVACUnitaryBypassVAV.unit.cc
@@ -190,20 +190,20 @@ class CBVAVSys : public EnergyPlusFixture
 
         // note no fan used for these tests
         state->dataHVACUnitaryBypassVAV->NumCBVAV = 1;
-        state->dataHVACUnitaryBypassVAV->CBVAV.allocate(1);
-        auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAV(1));
+        state->dataHVACUnitaryBypassVAV->CBVAVs.allocate(1);
+        auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAVs(1));
         cbvav.Name = "CBVAVAirLoop";
         cbvav.UnitType = "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass";
         cbvav.availSched = Sched::GetScheduleAlwaysOn(*state);
         cbvav.ControlledZoneNodeNum.allocate(1);
         cbvav.ControlledZoneNodeNum(1) = 1;
-        cbvav.DXCoolCoilIndexNum = 1;
+        cbvav.CoolCoilNum = 1;
         state->dataDXCoils->DXCoil.allocate(1);
         state->dataDXCoils->DXCoilNumericFields.allocate(1);
         state->dataDXCoils->DXCoilNumericFields(1).PerfMode.allocate(1);
         state->dataDXCoils->DXCoilNumericFields(1).PerfMode(1).FieldNames.allocate(20);
         state->dataDXCoils->DXCoil(1).Name = "MyDXCoolCoil";
-        state->dataDXCoils->DXCoil(1).DXCoilType = "COIL:COOLING:DX:SINGLESPEED";
+        state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingDXSingleSpeed;
         state->dataDXCoils->NumDXCoils = 1;
         state->dataDXCoils->CheckEquipName.dimension(1, true);
         state->dataDXCoils->GetCoilsInputFlag = false;
@@ -235,20 +235,22 @@ class CBVAVSys : public EnergyPlusFixture
         state->dataDXCoils->DXCoilFanOp.allocate(1);
         state->dataHeatBal->HeatReclaimDXCoil.allocate(1);
 
-        cbvav.DXCoolCoilName = "MyDXCoolCoil";
-        state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
+        state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingDXSingleSpeed;
         state->dataHeatingCoils->HeatingCoil.allocate(1);
         state->dataHeatingCoils->HeatingCoilNumericFields.allocate(1);
         state->dataHeatingCoils->HeatingCoilNumericFields(1).FieldNames.allocate(20);
         state->dataHeatingCoils->HeatingCoil(1).Name = "MyHeatingCoil";
-        state->dataHeatingCoils->HeatingCoil(1).HCoilType_Num = HVAC::Coil_HeatingElectric;
+        state->dataHeatingCoils->HeatingCoil(1).coilType = HVAC::CoilType::HeatingElectric;
         state->dataHeatingCoils->NumHeatingCoils = 1;
         state->dataHeatingCoils->ValidSourceType.dimension(state->dataHeatingCoils->NumHeatingCoils, false);
         state->dataHeatingCoils->GetCoilsInputFlag = false;
         state->dataSize->UnitarySysEqSizing.allocate(1);
+        cbvav.CoolCoilName = "MyDXCoolCoil";
+        cbvav.coolCoilType = HVAC::CoilType::CoolingDXSingleSpeed;
+        cbvav.CoolCoilNum = DXCoils::GetCoilIndex(*state, cbvav.CoolCoilName);
         cbvav.HeatCoilName = "MyHeatingCoil";
-        cbvav.CoolCoilType = HVAC::CoilType::DXCoolingSingleSpeed;
-        cbvav.HeatCoilType = HVAC::CoilType::HeatingElectric;
+        cbvav.heatCoilType = HVAC::CoilType::HeatingElectric;
+        cbvav.HeatCoilNum = HeatingCoils::GetCoilIndex(*state, cbvav.HeatCoilName);
         cbvav.minModeChangeTime = 0.0;
         cbvav.AirInNode = 1;
         cbvav.AirOutNode = 2;
@@ -256,7 +258,7 @@ class CBVAVSys : public EnergyPlusFixture
         cbvav.MixerReliefAirNode = 4;
         cbvav.MixerMixedAirNode = 5;
         cbvav.MixerInletAirNode = 6;
-        cbvav.HeatingCoilOutletNode = 9;
+        cbvav.HeatCoilAirOutletNode = 9;
         cbvav.SplitterOutletAirNode = 9;
         cbvav.NumControlledZones = 1;
         cbvav.ControlledZoneNum.allocate(1);
@@ -268,6 +270,8 @@ class CBVAVSys : public EnergyPlusFixture
         cbvav.ZoneSequenceCoolingNum = 1;
         cbvav.ZoneSequenceHeatingNum = 1;
         cbvav.OAMixName = "MyOAMixer";
+
+        state->dataMixedAir->NumOAMixers = 1;
         state->dataMixedAir->OAMixer.allocate(1);
         state->dataMixedAir->OAMixer(1).Name = "MyOAMixer";
         state->dataMixedAir->OAMixer(1).InletNode = 3;
@@ -275,14 +279,14 @@ class CBVAVSys : public EnergyPlusFixture
         state->dataMixedAir->OAMixer(1).RetNode = 6;
         state->dataMixedAir->OAMixer(1).MixNode = 7;
         state->dataDXCoils->DXCoil(1).AirInNode = 7;
-        cbvav.DXCoilInletNode = state->dataDXCoils->DXCoil(1).AirInNode;
+        cbvav.CoolCoilAirInletNode = state->dataDXCoils->DXCoil(1).AirInNode;
         state->dataDXCoils->DXCoil(1).AirOutNode = 8;
-        cbvav.DXCoilOutletNode = state->dataDXCoils->DXCoil(1).AirOutNode;
+        cbvav.CoolCoilAirOutletNode = state->dataDXCoils->DXCoil(1).AirOutNode;
         state->dataHeatingCoils->HeatingCoil(1).AirInletNodeNum = 8;
-        cbvav.HeatingCoilInletNode = state->dataHeatingCoils->HeatingCoil(1).AirInletNodeNum;
+        cbvav.HeatCoilAirInletNode = state->dataHeatingCoils->HeatingCoil(1).AirInletNodeNum;
         state->dataHeatingCoils->HeatingCoil(1).AirOutletNodeNum = 9;
         state->dataHeatingCoils->HeatingCoil(1).TempSetPointNodeNum = 9;
-        cbvav.HeatingCoilOutletNode = state->dataHeatingCoils->HeatingCoil(1).AirOutletNodeNum;
+        cbvav.HeatCoilAirOutletNode = state->dataHeatingCoils->HeatingCoil(1).AirOutletNodeNum;
         state->dataHeatingCoils->HeatingCoil(1).NominalCapacity = 10000.0;
         state->dataHeatingCoils->HeatingCoil(1).Efficiency = 1.0;
         state->dataHeatingCoils->HeatingCoil(1).availSched = Sched::GetScheduleAlwaysOn(*state);
@@ -684,7 +688,7 @@ TEST_F(EnergyPlusFixture, UnitaryBypassVAV_GetInputZoneEquipment)
 
     int CBVAVNum = 1;
     int zoneIndex = 1;
-    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAV(CBVAVNum));
+    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAVs(CBVAVNum));
     // should be the second zone in the zone list as well as actual zone number
     EXPECT_EQ(2, cbvav.ControlledZoneNum(CBVAVNum));
     // reflects sequence number in ZoneHVAC:EquipmentList
@@ -717,7 +721,7 @@ TEST_F(CBVAVSys, UnitaryBypassVAV_AutoSize)
 {
 
     //  reference CBVAV and FinalSysSizing data
-    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAV(1));
+    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAVs(1));
     auto &finalSysSizing(state->dataSize->FinalSysSizing(state->dataSize->CurSysNum));
 
     state->dataSize->SysSizingRunDone = true; // inform sizing that system sizing run is done
@@ -758,7 +762,7 @@ TEST_F(CBVAVSys, UnitaryBypassVAV_AutoSize)
 TEST_F(CBVAVSys, UnitaryBypassVAV_NoOASys)
 {
     //  reference CBVAV data
-    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAV(1));
+    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAVs(1));
     cbvav.FanVolFlow = 0.5;
     cbvav.MaxCoolAirVolFlow = 0.5;
     cbvav.MaxHeatAirVolFlow = 0.5;
@@ -853,7 +857,7 @@ TEST_F(CBVAVSys, UnitaryBypassVAV_InternalOAMixer)
 {
 
     //  reference CBVAV data
-    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAV(1));
+    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAVs(1));
     cbvav.FanVolFlow = 0.5;
     cbvav.MaxCoolAirVolFlow = 0.5;
     cbvav.MaxHeatAirVolFlow = 0.5;
@@ -940,7 +944,7 @@ TEST_F(CBVAVSys, UnitaryBypassVAV_Mixerconnected)
 {
 
     //  reference CBVAV data
-    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAV(1));
+    auto &cbvav(state->dataHVACUnitaryBypassVAV->CBVAVs(1));
     cbvav.FanVolFlow = 0.5;
     cbvav.MaxCoolAirVolFlow = 0.5;
     cbvav.MaxHeatAirVolFlow = 0.5;
@@ -1697,7 +1701,7 @@ TEST_F(EnergyPlusFixture, UnitaryBypassVAV_ParentElectricityRateTest)
     state->dataEnvrn->OutBaroPress = 101325.0;
     state->dataEnvrn->StdRhoAir = 1.20;
     // set shortcut to system
-    auto &BypassVAV = state->dataHVACUnitaryBypassVAV->CBVAV(1);
+    auto &BypassVAV = state->dataHVACUnitaryBypassVAV->CBVAVs(1);
     // set zone air conditions
     auto &zoneAirNode =
         state->dataLoopNodes->Node(Util::FindItemInList("ZONE 1 NODE", state->dataLoopNodes->NodeID, state->dataLoopNodes->NumOfNodes));
diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc
index b1ac3746de4..d24e712c2d1 100644
--- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc
+++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc
@@ -464,14 +464,14 @@ class AirLoopFixture : public EnergyPlusFixture
         VRFTU.OAMixerName = "OAMixer1";
         VRFTU.OAMixerIndex = 1;
         VRFTU.OAMixerUsed = true;
-        VRFTU.CoolCoilIndex = coolCoilIndex;
+        VRFTU.CoolCoilNum = coolCoilIndex;
         VRFTU.coolCoilAirInNode = coolCoilAirInNode;
         VRFTU.coolCoilAirOutNode = coolCoilAirOutNode;
-        VRFTU.HeatCoilIndex = heatCoilIndex;
+        VRFTU.HeatCoilNum = heatCoilIndex;
         VRFTU.heatCoilAirInNode = heatCoilAirInNode;
         VRFTU.heatCoilAirOutNode = heatCoilAirOutNode;
-        VRFTU.DXCoolCoilType_Num = HVAC::CoilVRF_Cooling;
-        VRFTU.DXHeatCoilType_Num = HVAC::CoilVRF_Heating;
+        VRFTU.coolCoilType = HVAC::CoilType::CoolingVRF;
+        VRFTU.heatCoilType = HVAC::CoilType::HeatingVRF;
         VRFTU.CoolingCoilPresent = true;
         VRFTU.HeatingCoilPresent = true;
         VRFTU.HVACSizingIndex = 0;
@@ -480,10 +480,9 @@ class AirLoopFixture : public EnergyPlusFixture
         state->dataDXCoils->DXCoilNumericFields(1).PerfMode.allocate(5);
         state->dataDXCoils->DXCoilNumericFields(1).PerfMode(1).FieldNames.allocate(30);
         state->dataDXCoils->DXCoil(1).Name = "VRFTUDXCOOLCOIL";
-        state->dataDXCoils->DXCoil(1).DXCoilType = "Coil:Cooling:DX:VariableRefrigerantFlow";
+        state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingVRF;
         state->dataDXCoils->DXCoil(1).AirInNode = coolCoilAirInNode;
         state->dataDXCoils->DXCoil(1).AirOutNode = coolCoilAirOutNode;
-        state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilVRF_Cooling;
         state->dataDXCoils->DXCoil(1).RatedAirVolFlowRate = DataSizing::AutoSize;
         state->dataDXCoils->DXCoil(1).RatedTotCap = DataSizing::AutoSize;
         state->dataDXCoils->DXCoil(1).RatedSHR = DataSizing::AutoSize;
@@ -498,10 +497,9 @@ class AirLoopFixture : public EnergyPlusFixture
         state->dataDXCoils->DXCoilNumericFields(2).PerfMode.allocate(5);
         state->dataDXCoils->DXCoilNumericFields(2).PerfMode(1).FieldNames.allocate(30);
         state->dataDXCoils->DXCoil(2).Name = "VRFTUDXHEATCOIL";
-        state->dataDXCoils->DXCoil(2).DXCoilType = "Coil:Heating:DX:VariableRefrigerantFlow";
         state->dataDXCoils->DXCoil(2).AirInNode = heatCoilAirInNode;
         state->dataDXCoils->DXCoil(2).AirOutNode = heatCoilAirOutNode;
-        state->dataDXCoils->DXCoil(2).DXCoilType_Num = HVAC::CoilVRF_Heating;
+        state->dataDXCoils->DXCoil(2).coilType = HVAC::CoilType::HeatingVRF;
         state->dataDXCoils->DXCoil(2).RatedAirVolFlowRate = DataSizing::AutoSize;
         state->dataDXCoils->DXCoil(2).RatedTotCap = DataSizing::AutoSize;
         state->dataDXCoils->DXCoil(2).RatedSHR = DataSizing::AutoSize;
@@ -2908,7 +2906,7 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_GetCoilInput)
 
     // Check the results
     ASSERT_EQ(1, state->dataDXCoils->NumDXCoils);
-    EXPECT_EQ(state->dataDXCoils->DXCoil(1).DXCoilType_Num, 33);
+    EXPECT_EQ(state->dataDXCoils->DXCoil(1).coilType, HVAC::CoilType::CoolingVRFFluidTCtrl);
     EXPECT_EQ(state->dataDXCoils->DXCoil(1).RatedTotCap(1), 2200);
     EXPECT_EQ(state->dataDXCoils->DXCoil(1).RatedSHR(1), 0.865);
     EXPECT_EQ(state->dataDXCoils->DXCoil(1).C1Te, 0);
@@ -3122,10 +3120,10 @@ TEST_F(EnergyPlusFixture, VRF_FluidTCtrl_CalcVRFIUTeTc)
     state->dataHVACVarRefFlow->VRF(IndexVRFCondenser).AlgorithmIUCtrl = 1;
     state->dataHVACVarRefFlow->VRF(IndexVRFCondenser).HeatRecoveryUsed = false;
     state->dataHVACVarRefFlow->VRFTU.allocate(state->dataHVACVarRefFlow->TerminalUnitList(IndexTUList).NumTUInList);
-    state->dataHVACVarRefFlow->VRFTU(1).CoolCoilIndex = 1;
-    state->dataHVACVarRefFlow->VRFTU(1).HeatCoilIndex = 2;
-    state->dataHVACVarRefFlow->VRFTU(2).CoolCoilIndex = 3;
-    state->dataHVACVarRefFlow->VRFTU(2).HeatCoilIndex = 4;
+    state->dataHVACVarRefFlow->VRFTU(1).CoolCoilNum = 1;
+    state->dataHVACVarRefFlow->VRFTU(1).HeatCoilNum = 2;
+    state->dataHVACVarRefFlow->VRFTU(2).CoolCoilNum = 3;
+    state->dataHVACVarRefFlow->VRFTU(2).HeatCoilNum = 4;
     state->dataHVACVarRefFlow->VRFTU(1).ZoneNum = 1;
     state->dataHVACVarRefFlow->VRFTU(1).VRFSysNum = 1;
     state->dataHVACVarRefFlow->VRFTU(2).ZoneNum = 2;
@@ -6861,8 +6859,8 @@ TEST_F(EnergyPlusFixture, VRFTest_CondenserCalcTest)
 
     state->dataHVACVarRefFlow->VRFTU.allocate(5);
     for (int NumTU = 1; NumTU <= state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList; ++NumTU) {
-        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilIndex = NumTU;
-        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilIndex = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilNum = NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilNum = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
         state->dataHVACVarRefFlow->TerminalUnitList(1).ZoneTUPtr(NumTU) = NumTU;
         // initialize DX coil inlet conditions
         state->dataDXCoils->DXCoilCoolInletAirWBTemp(NumTU) = 19.4;
@@ -8179,31 +8177,31 @@ TEST_F(EnergyPlusFixture, VRFTU_SupplementalHeatingCoilGetInput)
     auto &VRFTU_1(state->dataHVACVarRefFlow->VRFTU(1));
     // Check the results
     EXPECT_EQ(VRFTU_1.Name, "TU1");
-    EXPECT_EQ(VRFTU_1.SuppHeatCoilType, "COIL:HEATING:ELECTRIC");
+    EXPECT_ENUM_EQ(VRFTU_1.suppHeatCoilType, HVAC::CoilType::HeatingElectric);
     EXPECT_EQ(VRFTU_1.SuppHeatCoilName, "TU1 SUPP HEATING COIL");
 
     auto &VRFTU_2(state->dataHVACVarRefFlow->VRFTU(2));
     // Check the results
     EXPECT_EQ(VRFTU_2.Name, "TU2");
-    EXPECT_EQ(VRFTU_2.SuppHeatCoilType, "COIL:HEATING:FUEL");
+    EXPECT_ENUM_EQ(VRFTU_2.suppHeatCoilType, HVAC::CoilType::HeatingGasOrOtherFuel);
     EXPECT_EQ(VRFTU_2.SuppHeatCoilName, "TU2 SUPP HEATING COIL");
 
     auto &VRFTU_3(state->dataHVACVarRefFlow->VRFTU(3));
     // Check the results
     EXPECT_EQ(VRFTU_3.Name, "TU3");
-    EXPECT_EQ(VRFTU_3.SuppHeatCoilType, "COIL:HEATING:WATER");
+    EXPECT_ENUM_EQ(VRFTU_3.suppHeatCoilType, HVAC::CoilType::HeatingWater);
     EXPECT_EQ(VRFTU_3.SuppHeatCoilName, "TU3 SUPP HEATING COIL");
 
     auto &VRFTU_4(state->dataHVACVarRefFlow->VRFTU(4));
     // Check the results
     EXPECT_EQ(VRFTU_4.Name, "TU4");
-    EXPECT_EQ(VRFTU_4.SuppHeatCoilType, "COIL:HEATING:FUEL");
+    EXPECT_ENUM_EQ(VRFTU_4.suppHeatCoilType, HVAC::CoilType::HeatingGasOrOtherFuel);
     EXPECT_EQ(VRFTU_4.SuppHeatCoilName, "TU4 SUPP HEATING COIL");
 
     auto &VRFTU_5(state->dataHVACVarRefFlow->VRFTU(5));
     // Check the results
     EXPECT_EQ(VRFTU_5.Name, "TU5");
-    EXPECT_EQ(VRFTU_5.SuppHeatCoilType, "COIL:HEATING:STEAM");
+    EXPECT_ENUM_EQ(VRFTU_5.suppHeatCoilType, HVAC::CoilType::HeatingSteam);
     EXPECT_EQ(VRFTU_5.SuppHeatCoilName, "TU5 SUPP HEATING COIL");
 }
 
@@ -8217,14 +8215,13 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilElectric)
 
     int VRFTUNum(1);
     thisVRFTU.Name = "TU1";
-    thisVRFTU.SuppHeatCoilType = "COIL:HEATING:ELECTRIC";
+    thisVRFTU.suppHeatCoilType = HVAC::CoilType::HeatingElectric;
     thisVRFTU.SuppHeatCoilName = "TU1 SUPP HEATING COIL";
-    thisVRFTU.SuppHeatCoilType_Num = HVAC::Coil_HeatingElectric;
     thisVRFTU.fanOp = HVAC::FanOp::Continuous;
     thisVRFTU.type = TUType::ConstantVolume;
     thisVRFTU.SuppHeatCoilAirInletNode = 1;
     thisVRFTU.SuppHeatCoilAirOutletNode = 2;
-    thisVRFTU.SuppHeatCoilIndex = 1;
+    thisVRFTU.SuppHeatCoilNum = 1;
     thisVRFTU.MaxOATSuppHeatingCoil = 21.0;
     thisVRFTU.MaxSATFromSuppHeatCoil = 50.0;
     thisVRFTU.SuppHeatPartLoadRatio = 1.0;
@@ -8236,9 +8233,8 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilElectric)
     state->dataHeatingCoils->HeatingCoil.allocate(state->dataHeatingCoils->NumHeatingCoils);
     state->dataHeatingCoils->CoilIsSuppHeater = true;
     state->dataHeatingCoils->HeatingCoil(CoilNum).Name = thisVRFTU.SuppHeatCoilName;
-    state->dataHeatingCoils->HeatingCoil(CoilNum).HeatingCoilType = thisVRFTU.SuppHeatCoilType;
+    state->dataHeatingCoils->HeatingCoil(CoilNum).coilType = thisVRFTU.suppHeatCoilType;
     state->dataHeatingCoils->HeatingCoil(CoilNum).FuelType = Constant::eFuel::Electricity;
-    state->dataHeatingCoils->HeatingCoil(CoilNum).HCoilType_Num = thisVRFTU.SuppHeatCoilType_Num;
     state->dataHeatingCoils->HeatingCoil(CoilNum).AirInletNodeNum = thisVRFTU.SuppHeatCoilAirInletNode;
     state->dataHeatingCoils->HeatingCoil(CoilNum).AirOutletNodeNum = thisVRFTU.SuppHeatCoilAirOutletNode;
     state->dataHeatingCoils->HeatingCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOn(*state); // fan is always on
@@ -8282,14 +8278,13 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilFuel)
 
     int VRFTUNum(1);
     thisVRFTU.Name = "TU2";
-    thisVRFTU.SuppHeatCoilType = "COIL:HEATING:FUEL";
     thisVRFTU.SuppHeatCoilName = "TU2 SUPP HEATING COIL";
-    thisVRFTU.SuppHeatCoilType_Num = HVAC::Coil_HeatingGasOrOtherFuel;
+    thisVRFTU.suppHeatCoilType = HVAC::CoilType::HeatingGasOrOtherFuel;
     thisVRFTU.fanOp = HVAC::FanOp::Continuous;
     thisVRFTU.type = TUType::ConstantVolume;
     thisVRFTU.SuppHeatCoilAirInletNode = 1;
     thisVRFTU.SuppHeatCoilAirOutletNode = 2;
-    thisVRFTU.SuppHeatCoilIndex = 1;
+    thisVRFTU.SuppHeatCoilNum = 1;
     thisVRFTU.MaxOATSuppHeatingCoil = 21.0;
     thisVRFTU.MaxSATFromSuppHeatCoil = 50.0;
     thisVRFTU.SuppHeatPartLoadRatio = 1.0;
@@ -8301,9 +8296,8 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilFuel)
     state->dataHeatingCoils->HeatingCoil.allocate(state->dataHeatingCoils->NumHeatingCoils);
     state->dataHeatingCoils->CoilIsSuppHeater = true;
     state->dataHeatingCoils->HeatingCoil(CoilNum).Name = thisVRFTU.SuppHeatCoilName;
-    state->dataHeatingCoils->HeatingCoil(CoilNum).HeatingCoilType = thisVRFTU.SuppHeatCoilType;
+    state->dataHeatingCoils->HeatingCoil(CoilNum).coilType = thisVRFTU.suppHeatCoilType;
     state->dataHeatingCoils->HeatingCoil(CoilNum).FuelType = Constant::eFuel::NaturalGas;
-    state->dataHeatingCoils->HeatingCoil(CoilNum).HCoilType_Num = thisVRFTU.SuppHeatCoilType_Num;
     state->dataHeatingCoils->HeatingCoil(CoilNum).AirInletNodeNum = thisVRFTU.SuppHeatCoilAirInletNode;
     state->dataHeatingCoils->HeatingCoil(CoilNum).AirOutletNodeNum = thisVRFTU.SuppHeatCoilAirOutletNode;
     state->dataHeatingCoils->HeatingCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOn(*state); // fan is always on
@@ -8347,14 +8341,13 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilWater)
 
     int VRFTUNum(1);
     thisVRFTU.Name = "TU3";
-    thisVRFTU.SuppHeatCoilType = "COIL:HEATING:WATER";
     thisVRFTU.SuppHeatCoilName = "TU3 SUPP HEATING COIL";
-    thisVRFTU.SuppHeatCoilType_Num = HVAC::Coil_HeatingWater;
+    thisVRFTU.suppHeatCoilType = HVAC::CoilType::HeatingWater;
     thisVRFTU.fanOp = HVAC::FanOp::Continuous;
     thisVRFTU.type = TUType::ConstantVolume;
     thisVRFTU.SuppHeatCoilAirInletNode = 1;
     thisVRFTU.SuppHeatCoilAirOutletNode = 2;
-    thisVRFTU.SuppHeatCoilIndex = 1;
+    thisVRFTU.SuppHeatCoilNum = 1;
     thisVRFTU.MaxOATSuppHeatingCoil = 21.0;
     thisVRFTU.MaxSATFromSuppHeatCoil = 50.0;
     thisVRFTU.SuppHeatPartLoadRatio = 1.0;
@@ -8367,9 +8360,8 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilWater)
     state->dataWaterCoils->NumWaterCoils = 1;
     state->dataWaterCoils->WaterCoil.allocate(state->dataWaterCoils->NumWaterCoils);
     state->dataWaterCoils->WaterCoil(CoilNum).Name = thisVRFTU.SuppHeatCoilName;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::HeatingSimple;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilTypeA = "Heating";
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::HeatingWater;
     state->dataWaterCoils->WaterCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOn(*state);
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
 
@@ -8468,13 +8460,12 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilSteam)
 
     int VRFTUNum(1);
     thisVRFTU.Name = "TU4";
-    thisVRFTU.SuppHeatCoilType = "COIL:HEATING:STEAM";
     thisVRFTU.SuppHeatCoilName = "TU4 SUPP HEATING COIL";
-    thisVRFTU.SuppHeatCoilType_Num = HVAC::Coil_HeatingSteam;
+    thisVRFTU.suppHeatCoilType = HVAC::CoilType::HeatingSteam;
     thisVRFTU.fanOp = HVAC::FanOp::Continuous;
     thisVRFTU.SuppHeatCoilAirInletNode = 1;
     thisVRFTU.SuppHeatCoilAirOutletNode = 2;
-    thisVRFTU.SuppHeatCoilIndex = 1;
+    thisVRFTU.SuppHeatCoilNum = 1;
     thisVRFTU.MaxOATSuppHeatingCoil = 21.0;
     thisVRFTU.MaxSATFromSuppHeatCoil = 50.0;
     thisVRFTU.SuppHeatPartLoadRatio = 1.0;
@@ -8579,7 +8570,7 @@ TEST_F(EnergyPlusFixture, VRFTU_SupplementalHeatingCoilCapacityLimitTest)
     VRFTerminalUnitEquipment thisVRFTU;
 
     thisVRFTU.Name = "TU1";
-    thisVRFTU.SuppHeatCoilType = "COIL:HEATING:ELECTRIC";
+    thisVRFTU.suppHeatCoilType = HVAC::CoilType::HeatingElectric;
     thisVRFTU.SuppHeatCoilName = "TU1 SUPP HEATING COIL";
 
     thisVRFTU.SuppHeatCoilAirInletNode = 1;
@@ -13464,8 +13455,8 @@ TEST_F(EnergyPlusFixture, VRFTest_CondenserCalcTest_HREIRFTHeat)
 
     state->dataHVACVarRefFlow->VRFTU.allocate(5);
     for (int NumTU = 1; NumTU <= state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList; ++NumTU) {
-        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilIndex = NumTU;
-        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilIndex = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilNum = NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilNum = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
         state->dataHVACVarRefFlow->TerminalUnitList(1).ZoneTUPtr(NumTU) = NumTU;
         // initialize DX coil inlet conditions
         state->dataDXCoils->DXCoilCoolInletAirWBTemp(NumTU) = 19.4;
@@ -16114,8 +16105,8 @@ TEST_F(EnergyPlusFixture, VRF_Condenser_Calc_EIRFPLR_Bound_Test)
 
     state->dataHVACVarRefFlow->VRFTU.allocate(5);
     for (int NumTU = 1; NumTU <= state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList; ++NumTU) {
-        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilIndex = NumTU;
-        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilIndex = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilNum = NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilNum = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
         state->dataHVACVarRefFlow->TerminalUnitList(1).ZoneTUPtr(NumTU) = NumTU;
         // initialize DX coil inlet conditions
         state->dataDXCoils->DXCoilCoolInletAirWBTemp(NumTU) = 19.4;
@@ -22998,8 +22989,8 @@ TEST_F(EnergyPlusFixture, VRFHP_CondenserCalc_PLR_Issue_Test)
 
     state->dataHVACVarRefFlow->VRFTU.allocate(5);
     for (int NumTU = 1; NumTU <= state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList; ++NumTU) {
-        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilIndex = NumTU;
-        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilIndex = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).CoolCoilNum = NumTU;
+        state->dataHVACVarRefFlow->VRFTU(NumTU).HeatCoilNum = state->dataHVACVarRefFlow->TerminalUnitList(1).NumTUInList + NumTU;
         state->dataHVACVarRefFlow->TerminalUnitList(1).ZoneTUPtr(NumTU) = NumTU;
         // initialize DX coil inlet conditions
         state->dataDXCoils->DXCoilCoolInletAirWBTemp(NumTU) = 19.4;
diff --git a/tst/EnergyPlus/unit/HeatRecovery.unit.cc b/tst/EnergyPlus/unit/HeatRecovery.unit.cc
index 70d88ff9750..4af98c33da9 100644
--- a/tst/EnergyPlus/unit/HeatRecovery.unit.cc
+++ b/tst/EnergyPlus/unit/HeatRecovery.unit.cc
@@ -159,7 +159,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
 
     auto &thisHX = state->dataHeatRecovery->ExchCond(ExchNum);
     // HXUnitOn is false so expect outlet = inlet
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     Toutlet = state->dataHeatRecovery->ExchCond(ExchNum).SupInTemp;
@@ -172,7 +172,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
     // HXUnitOn is true and ControlToTemperatureSetPoint is false so expect outlet = temperature based on effectiveness
     HXUnitOn = true;
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Plate;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     Toutlet = (state->dataHeatRecovery->ExchCond(ExchNum).SupInTemp +
@@ -183,7 +183,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
 
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Rotary;
     HXUnitOn = true;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     Toutlet = (state->dataHeatRecovery->ExchCond(ExchNum).SupInTemp +
@@ -198,7 +198,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
     // HXUnitOn is true and ControlToTemperatureSetPoint is true so expect outlet = set point temperature
     HXUnitOn = true;
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Plate;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     Toutlet = SetPointTemp;
@@ -207,7 +207,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
 
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Rotary;
     HXUnitOn = true;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     Toutlet = state->dataLoopNodes->Node(state->dataHeatRecovery->ExchCond(ExchNum).SupOutletNode).TempSetPoint;
@@ -241,7 +241,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
 
     // HXUnitOn is false so expect outlet = inlet
     HXUnitOn = false;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ(state->dataHeatRecovery->ExchCond(ExchNum).SupInTemp,
@@ -253,7 +253,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
     // HXUnitOn is true and ControlToTemperatureSetPoint is false so expect outlet = temperature based on effectiveness
     HXUnitOn = true;
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Plate;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ((state->dataHeatRecovery->ExchCond(ExchNum).SupInTemp +
@@ -263,7 +263,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
 
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Rotary;
     HXUnitOn = true;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ((state->dataHeatRecovery->ExchCond(ExchNum).SupInTemp +
@@ -277,7 +277,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
     // HXUnitOn is true and ControlToTemperatureSetPoint is true so expect outlet = set point temperature
     HXUnitOn = true;
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Plate;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ(state->dataLoopNodes->Node(state->dataHeatRecovery->ExchCond(ExchNum).SupOutletNode).TempSetPoint,
@@ -285,7 +285,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
 
     state->dataHeatRecovery->ExchCond(ExchNum).ExchConfig = HXConfigurationType::Rotary;
     HXUnitOn = true;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ(state->dataLoopNodes->Node(state->dataHeatRecovery->ExchCond(ExchNum).SupOutletNode).TempSetPoint,
@@ -298,7 +298,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HRTest)
     state->dataLoopNodes->Node(state->dataHeatRecovery->ExchCond(ExchNum).SecInletNode).MassFlowRate =
         state->dataHeatRecovery->ExchCond(ExchNum).SecInMassFlow / 4.0;
     state->dataHeatRecovery->ExchCond(ExchNum).ControlToTemperatureSetPoint = false;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag, PartLoadRatio);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ((state->dataHeatRecovery->ExchCond(ExchNum).SupInTemp +
@@ -509,7 +509,7 @@ TEST_F(EnergyPlusFixture, HeatRecoveryHXOnManinBranch_GetInputTest)
 
     GetReturnAirPathInput(*state);
     GetAirPathData(*state);
-    ASSERT_ENUM_EQ(SimAirServingZones::CompType::HeatXchngr, state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(4).CompType_Num);
+    ASSERT_ENUM_EQ(SimAirServingZones::CompType::HeatXchngr, state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(4).compType);
 }
 
 TEST_F(EnergyPlusFixture, HeatRecoveryHXOnMainBranch_SimHeatRecoveryTest)
@@ -4207,7 +4207,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HeatExchangerGenericCalcTest)
     thisHX.NomSecAirVolFlow = thisHX.NomSupAirVolFlow;
     state->dataLoopNodes->Node(thisHX.SecInletNode).MassFlowRate = thisHX.NomSecAirVolFlow * state->dataEnvrn->StdRhoAir;
     state->dataLoopNodes->Node(thisHX.SupOutletNode).TempSetPoint = 19.0;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ(10.0, thisHX.SupInTemp);
@@ -4223,7 +4223,7 @@ TEST_F(EnergyPlusFixture, HeatRecovery_HeatExchangerGenericCalcTest)
     thisHX.NomSecAirVolFlow = 10.0 * thisHX.NomSupAirVolFlow;
     state->dataLoopNodes->Node(thisHX.SecInletNode).MassFlowRate = thisHX.NomSecAirVolFlow * state->dataEnvrn->StdRhoAir;
     state->dataLoopNodes->Node(thisHX.SupOutletNode).TempSetPoint = 19.0;
-    thisHX.initialize(*state, CompanionCoilNum, 0);
+    thisHX.initialize(*state, CompanionCoilNum, HVAC::CoilType::Invalid);
     thisHX.CalcAirToAirGenericHeatExch(*state, HXUnitOn, FirstHVACIteration, fanOp, EconomizerFlag, HighHumCtrlFlag);
     thisHX.UpdateHeatRecovery(*state);
     EXPECT_DOUBLE_EQ(10.0, thisHX.SupInTemp);
diff --git a/tst/EnergyPlus/unit/HeatingCoils.unit.cc b/tst/EnergyPlus/unit/HeatingCoils.unit.cc
index 290f6bd7535..fa620fe1040 100644
--- a/tst/EnergyPlus/unit/HeatingCoils.unit.cc
+++ b/tst/EnergyPlus/unit/HeatingCoils.unit.cc
@@ -100,11 +100,12 @@ TEST_F(EnergyPlusFixture, HeatingCoils_FuelTypeInputError)
 
     std::string const error_string = delimited_string({
         "   ** Severe  ** <root>[Coil:Heating:Fuel][Furnace Coil][fuel_type] - \"Electricity\" - Failed to match against any enum values.",
-        "   ** Severe  ** GetHeatingCoilInput: Coil:Heating:Fuel: Invalid Fuel Type entered =ELECTRICITY for Name=FURNACE COIL",
+        "   ** Severe  ** GetHeatingCoilInput: Coil:Heating:Fuel = FURNACE COIL",
+        "   **   ~~~   ** Fuel Type = ELECTRICITY, invalid key.",
         "   **  Fatal  ** GetHeatingCoilInput: Errors found in input.  Program terminates.",
         "   ...Summary of Errors that led to program termination:",
         "   ..... Reference severe error count=2",
-        "   ..... Last severe error=GetHeatingCoilInput: Coil:Heating:Fuel: Invalid Fuel Type entered =ELECTRICITY for Name=FURNACE COIL",
+        "   ..... Last severe error=GetHeatingCoilInput: Coil:Heating:Fuel = FURNACE COIL"
     });
 
     EXPECT_TRUE(compare_err_stream(error_string, true));
diff --git a/tst/EnergyPlus/unit/IntegratedHeatPump.unit.cc b/tst/EnergyPlus/unit/IntegratedHeatPump.unit.cc
index f8b43c3b5ad..8dc0dd49268 100644
--- a/tst/EnergyPlus/unit/IntegratedHeatPump.unit.cc
+++ b/tst/EnergyPlus/unit/IntegratedHeatPump.unit.cc
@@ -91,12 +91,8 @@ TEST_F(EnergyPlusFixture, ASIHP_GetCoilIndexIHP)
 
     state->dataIntegratedHP->IntegratedHeatPumps.push_back(IHP);
 
-    EXPECT_EQ(0, GetCoilIndexIHP(*state, "", "", ErrorsFound));
-    EXPECT_TRUE(ErrorsFound);
-
-    ErrorsFound = false;
-    EXPECT_EQ(1, GetCoilIndexIHP(*state, "", "ASIHP", ErrorsFound));
-    EXPECT_FALSE(ErrorsFound);
+    EXPECT_EQ(0, IntegratedHeatPump::GetIHPIndex(*state, ""));
+    EXPECT_EQ(1, IntegratedHeatPump::GetIHPIndex(*state, "ASIHP"));
 }
 
 TEST_F(EnergyPlusFixture, ASIHP_GetCoilInletNodeIHP)
@@ -114,12 +110,7 @@ TEST_F(EnergyPlusFixture, ASIHP_GetCoilInletNodeIHP)
 
     state->dataIntegratedHP->IntegratedHeatPumps.push_back(IHP);
 
-    EXPECT_EQ(0, GetCoilInletNodeIHP(*state, "", "", ErrorsFound));
-    EXPECT_TRUE(ErrorsFound);
-
-    ErrorsFound = false;
-    EXPECT_EQ(999, GetCoilInletNodeIHP(*state, "", "ASIHP", ErrorsFound));
-    EXPECT_FALSE(ErrorsFound);
+    EXPECT_EQ(999, IntegratedHeatPump::GetIHPCoilAirInletNode(*state, IntegratedHeatPump::GetIHPIndex(*state, "ASIHP")));
 }
 
 TEST_F(EnergyPlusFixture, ASIHP_GetLowSpeedNumIHP)
@@ -185,12 +176,12 @@ TEST_F(EnergyPlusFixture, ASIHP_GetMaxSpeedNumIHP)
     IHP.MinSpedSCWH = 9;
     IHP.MinSpedSCDWH = 99;
     IHP.MinSpedSHDWH = 999;
-    IHP.SCCoilIndex = 1;
-    IHP.SHCoilIndex = 1;
-    IHP.DWHCoilIndex = 1;
-    IHP.SCWHCoilIndex = 1;
-    IHP.SCDWHCoolCoilIndex = 1;
-    IHP.SHDWHHeatCoilIndex = 1;
+    IHP.SCCoilNum = 1;
+    IHP.SHCoilNum = 1;
+    IHP.DWHCoilNum = 1;
+    IHP.SCWHCoilNum = 1;
+    IHP.SCDWHCoolCoilNum = 1;
+    IHP.SHDWHHeatCoilNum = 1;
     // don't size for this test
     IHP.IHPCoilsSized = true;
 
diff --git a/tst/EnergyPlus/unit/OutputReportTabular.unit.cc b/tst/EnergyPlus/unit/OutputReportTabular.unit.cc
index 2d1bca7d726..49bd4a38703 100644
--- a/tst/EnergyPlus/unit/OutputReportTabular.unit.cc
+++ b/tst/EnergyPlus/unit/OutputReportTabular.unit.cc
@@ -3731,7 +3731,7 @@ TEST_F(EnergyPlusFixture, OutputReportTabular_GatherHeatEmissionReport)
 
     state->dataDXCoils->NumDXCoils = 2;
     state->dataDXCoils->DXCoil.allocate(2);
-    state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
+    state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingDXMultiSpeed;
     state->dataDXCoils->DXCoil(1).CondenserType(1) = DataHeatBalance::RefrigCondenserType::Air;
     state->dataDXCoils->DXCoil(1).FuelType = Constant::eFuel::NaturalGas;
     state->dataDXCoils->DXCoil(1).ElecCoolingConsumption = 100.0;
@@ -3739,7 +3739,7 @@ TEST_F(EnergyPlusFixture, OutputReportTabular_GatherHeatEmissionReport)
     state->dataDXCoils->DXCoil(1).MSFuelWasteHeat = 1.0;
     state->dataDXCoils->DXCoil(1).DefrostConsumption = 0.0;
     state->dataDXCoils->DXCoil(1).CrankcaseHeaterConsumption = 0.0;
-    state->dataDXCoils->DXCoil(2).DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    state->dataDXCoils->DXCoil(2).coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     state->dataDXCoils->DXCoil(2).ElecHeatingConsumption = 50.0;
     state->dataDXCoils->DXCoil(2).TotalHeatingEnergy = 40.0;
     state->dataDXCoils->DXCoil(2).DefrostConsumption = 0.0;
@@ -3754,7 +3754,7 @@ TEST_F(EnergyPlusFixture, OutputReportTabular_GatherHeatEmissionReport)
     EXPECT_EQ(2 * condenserReject * Constant::convertJtoGJ + coilReject * Constant::convertJtoGJ,
               state->dataHeatBal->BuildingPreDefRep.emiHVACReject);
 
-    state->dataDXCoils->DXCoil(1).DXCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
+    state->dataDXCoils->DXCoil(1).coilType = HVAC::CoilType::CoolingDXMultiSpeed;
     state->dataDXCoils->DXCoil(1).CondenserType(1) = DataHeatBalance::RefrigCondenserType::Air;
     state->dataDXCoils->DXCoil(1).FuelType = Constant::eFuel::NaturalGas;
     state->dataDXCoils->DXCoil(1).ElecCoolingConsumption = 100.0;
@@ -3763,7 +3763,7 @@ TEST_F(EnergyPlusFixture, OutputReportTabular_GatherHeatEmissionReport)
     state->dataDXCoils->DXCoil(1).DefrostConsumption = 0.0;
     state->dataDXCoils->DXCoil(1).CrankcaseHeaterConsumption = 20.0;
     state->dataDXCoils->DXCoil(1).FuelConsumed = 50.0; // not included for cooling
-    state->dataDXCoils->DXCoil(2).DXCoilType_Num = HVAC::CoilDX_MultiSpeedHeating;
+    state->dataDXCoils->DXCoil(2).coilType = HVAC::CoilType::HeatingDXMultiSpeed;
     state->dataDXCoils->DXCoil(2).ElecHeatingConsumption = 15.0;
     state->dataDXCoils->DXCoil(2).TotalHeatingEnergy = 100.0;
     state->dataDXCoils->DXCoil(2).DefrostConsumption = 10.0;
@@ -6529,7 +6529,6 @@ TEST_F(EnergyPlusFixture, OutputReportTabularMonthly_invalidAggregationOrder)
 TEST_F(EnergyPlusFixture, OutputReportTabularTest_CollectPeakZoneConditions_test)
 {
     state->init_state(*state);
-    createCoilSelectionReportObj(*state);
 
     CompLoadTablesType compLoad;
     int timeOfMax = 63;
@@ -7022,8 +7021,6 @@ TEST_F(SQLiteFixture, OutputReportTabular_WriteLoadComponentSummaryTables_AirLoo
     state->dataOutRptTab->displayFacilityComponentLoadSummary = true;
     state->dataGlobal->CompLoadReportIsReq = true;
 
-    createCoilSelectionReportObj(*state);
-
     // Two design days
     int numDesDays = 2;
     state->dataEnvrn->TotDesDays = numDesDays;
diff --git a/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc b/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc
index 041a7845509..a68a910a998 100644
--- a/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc
+++ b/tst/EnergyPlus/unit/PackagedTerminalHeatPump.unit.cc
@@ -857,8 +857,8 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimPTAC_HeatingCoilTest)
     //// get input test for terminal air single duct mixer on inlet side of PTAC
     ASSERT_EQ(1, state->dataUnitarySystems->numUnitarySystems);
     EXPECT_EQ("ZoneHVAC:PackagedTerminalAirConditioner", thisSys.UnitType);                             // zoneHVAC equipment type
-    EXPECT_EQ("COIL:HEATING:FUEL", thisSys.m_HeatingCoilTypeName);                                      // PTAC heating coil type
-    EXPECT_EQ(state->dataHeatingCoils->HeatingCoil(1).HCoilType_Num, HVAC::Coil_HeatingGasOrOtherFuel); // gas heating coil type
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingGasOrOtherFuel, thisSys.m_heatCoilType);                                      // PTAC heating coil type
+    EXPECT_ENUM_EQ(state->dataHeatingCoils->HeatingCoil(1).coilType, HVAC::CoilType::HeatingGasOrOtherFuel);
 
     state->dataGlobal->BeginEnvrnFlag = false;
 
@@ -3927,7 +3927,10 @@ TEST_F(EnergyPlusFixture, PTACDrawAirfromReturnNodeAndPlenum_Test)
     Sched::GetSchedule(*state, "CONTSFANSCH")->currentVal = 1.0;           // constant fan sch, ContsFanSch
     Sched::GetSchedule(*state, "FANAVAILSCHED")->currentVal = 1.0;         // Fan availability
 
-    int oaNode = 36; // this node index may change based on component calling order
+    int oaNode = 31; // this node index may change based on component calling order
+    // I had to change this from 36 to 31.  Can we make this more
+    // robust?  Can we do this via lookup on node name instead?
+    
     state->dataLoopNodes->Node(oaNode).MassFlowRate = 0.26908 * 1.2;
     state->dataLoopNodes->Node(oaNode).Temp = state->dataEnvrn->OutDryBulbTemp;
     state->dataLoopNodes->Node(oaNode).HumRat = state->dataEnvrn->OutHumRat;
@@ -3950,7 +3953,7 @@ TEST_F(EnergyPlusFixture, PTACDrawAirfromReturnNodeAndPlenum_Test)
     int mixerReturnNode = state->dataMixedAir->OAMixer(1).RetNode;
     int mixerMixedNode = state->dataMixedAir->OAMixer(1).MixNode;
     // if this EXPECT_EQ fails, node numbers have changed, change OA node number above to match mixerInletNode
-    EXPECT_EQ(36, mixerInletNode);
+    EXPECT_EQ(oaNode, mixerInletNode);
     state->dataLoopNodes->Node(mixerInletNode).MassFlowRate = 0.26908 * 1.2;
     state->dataLoopNodes->Node(mixerInletNode).Temp = state->dataEnvrn->OutDryBulbTemp;
     state->dataLoopNodes->Node(mixerInletNode).HumRat = state->dataEnvrn->OutHumRat;
@@ -4910,8 +4913,8 @@ TEST_F(EnergyPlusFixture, PTAC_AvailabilityManagerTest)
     // get input test for terminal air single duct mixer on inlet side of PTAC
     ASSERT_EQ(1, state->dataUnitarySystems->numUnitarySystems);
     EXPECT_EQ("ZoneHVAC:PackagedTerminalAirConditioner", thisSys.UnitType);
-    EXPECT_EQ("COIL:HEATING:FUEL", thisSys.m_HeatingCoilTypeName);
-    EXPECT_EQ(state->dataHeatingCoils->HeatingCoil(1).HCoilType_Num, HVAC::Coil_HeatingGasOrOtherFuel);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingGasOrOtherFuel, thisSys.m_heatCoilType);
+    EXPECT_ENUM_EQ(state->dataHeatingCoils->HeatingCoil(1).coilType, HVAC::CoilType::HeatingGasOrOtherFuel);
     EXPECT_FALSE(thisSys.m_useNoLoadLowSpeedAirFlow);
     // set input variables
     state->dataEnvrn->OutBaroPress = 101325.0;
diff --git a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc
index 1724917e928..7c9f7060756 100644
--- a/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc
+++ b/tst/EnergyPlus/unit/PoweredInductionUnits.unit.cc
@@ -565,7 +565,7 @@ TEST_F(EnergyPlusFixture, PIUArrayOutOfBounds)
     int PIUNum = 1;
     state->dataPowerInductionUnits->PIU(PIUNum).Name = "Series PIU";
     state->dataPowerInductionUnits->PIU(PIUNum).UnitType_Num = DataDefineEquip::ZnAirLoopEquipType::SingleDuct_SeriesPIU_Reheat;
-    state->dataPowerInductionUnits->PIU(PIUNum).HCoilType = PoweredInductionUnits::HtgCoilType::Electric;
+    state->dataPowerInductionUnits->PIU(PIUNum).heatCoilType = HVAC::CoilType::HeatingElectric;
 
     // Go into all of the autosize blocks (aside from Heating/Steam coils)
     state->dataPowerInductionUnits->PIU(PIUNum).MaxPriAirVolFlow = AutoSize;
@@ -3098,7 +3098,7 @@ TEST_F(EnergyPlusFixture, PIU_reportTerminalUnit)
     piu(1).UnitType = "AirTerminal:SingleDuct:SeriesPIU:Reheat";
     piu(1).MaxPriAirVolFlow = 0.30;
     piu(1).MaxSecAirVolFlow = 0.25;
-    piu(1).HCoilType = PoweredInductionUnits::HtgCoilType::Electric;
+    piu(1).heatCoilType = HVAC::CoilType::HeatingElectric;
     piu(1).fanType = HVAC::FanType::Constant;
     piu(1).FanName = "FanA";
 
diff --git a/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc b/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc
index 538a3585328..332538f19fb 100644
--- a/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc
+++ b/tst/EnergyPlus/unit/ReportCoilSelection.unit.cc
@@ -71,7 +71,7 @@ using namespace EnergyPlus;
 TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
 {
     std::string coil1Name("Coil 1");             // user-defined name of the coil
-    std::string coil1Type("Coil:Cooling:Water"); // idf input object class name of coil
+    HVAC::CoilType coil1Type = HVAC::CoilType::CoolingWater;
     int chWInletNodeNum = 9;
     int chWOutletNodeNum = 15;
 
@@ -99,10 +99,10 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
 
     Real64 airVdot(0.052);   // air flow rate in m3/s
     bool isAutoSized(false); // true if autosized
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(*state, coil1Name, coil1Type, airVdot, isAutoSized);
-    auto &c1(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0]);
+    ReportCoilSelection::setCoilAirFlow(*state, coil1Name, coil1Type, airVdot, isAutoSized);
+    auto *c1 = state->dataRptCoilSelection->coils[0];
     EXPECT_EQ(coil1Name, c1->coilName_);
-    EXPECT_EQ(coil1Type, c1->coilObjName);
+    EXPECT_EQ(coil1Type, c1->coilType);
     EXPECT_EQ(airVdot, c1->coilDesVolFlow);
     EXPECT_EQ(isAutoSized, c1->volFlowIsAutosized);
 
@@ -110,7 +110,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
     Real64 waterVdot = 0.05;
     // First with no plant sizing objects defined
     isAutoSized = false; // true if autosized
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(
+    ReportCoilSelection::setCoilWaterFlowNodeNums(
         *state, coil1Name, coil1Type, waterVdot, isAutoSized, chWInletNodeNum, chWOutletNodeNum, loopNum);
     EXPECT_EQ(-999, c1->pltSizNum);
     EXPECT_EQ(loopNum, c1->waterLoopNum);
@@ -121,15 +121,14 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
     EXPECT_EQ("No", c1->coilWaterFlowAutoMsg);
 
     // Exercise report writing with mostly defaults
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 
     // Use the other form for coil 2
     std::string coil2Name("Coil 2");             // user-defined name of the coil
-    std::string coil2Type("Coil:Cooling:Water"); // idf input object class name of coil
+    HVAC::CoilType coil2Type = HVAC::CoilType::CoolingWater;
     int pltSizNum = -999;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(
-        *state, coil2Name, coil2Type, waterVdot, isAutoSized, pltSizNum, loopNum);
-    auto &c2(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[1]);
+    ReportCoilSelection::setCoilWaterFlowPltSizNum(*state, coil2Name, coil2Type, waterVdot, isAutoSized, pltSizNum, loopNum);
+    auto *c2 = state->dataRptCoilSelection->coils[1];
     EXPECT_EQ(-999, c2->pltSizNum);
     EXPECT_EQ(loopNum, c2->waterLoopNum);
     EXPECT_EQ(state->dataPlnt->PlantLoop(1).Name, c2->plantLoopName);
@@ -143,9 +142,9 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
     state->dataSize->PlantSizData.allocate(1);
     state->dataSize->PlantSizData(1).PlantLoopName = "Chilled Water Loop";
     isAutoSized = true; // true if autosized
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(
+    ReportCoilSelection::setCoilWaterFlowNodeNums(
         *state, coil1Name, coil1Type, waterVdot, isAutoSized, chWInletNodeNum, chWOutletNodeNum, loopNum);
-    auto &c1b(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0]);
+    auto *c1b = state->dataRptCoilSelection->coils[0];
     EXPECT_EQ(1, c1b->pltSizNum);
     EXPECT_EQ(loopNum, c1b->waterLoopNum);
     EXPECT_EQ(state->dataPlnt->PlantLoop(1).Name, c1b->plantLoopName);
@@ -173,7 +172,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
     state->dataHeatBal->Zone(3).Name = "Zone 3";
 
     // This triggers doAirLoopSetUp
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilUA(*state, coil2Name, coil2Type, uA, sizingCap, isAutoSized, curSysNum, curZoneEqNum);
+    ReportCoilSelection::setCoilUA(*state, coil2Name, coil2Type, uA, sizingCap, isAutoSized, curSysNum, curZoneEqNum);
     EXPECT_EQ(uA, c2->coilUA);
     EXPECT_EQ(sizingCap, c2->coilTotCapAtPeak);
     EXPECT_EQ(curSysNum, c2->airloopNum);
@@ -182,26 +181,26 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
     // This coil serves zones 2 and 3 - rmLatentAtPeak is summed for all applicable zones
     Real64 zoneCoolingLatentLoad = 1000.0;
     int zoneNum = 1;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadCoolingIdealPeak(zoneNum, zoneCoolingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(*state, zoneNum, zoneCoolingLatentLoad);
     EXPECT_EQ(0.0, c2->rmLatentAtPeak);
     zoneNum = 2;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadCoolingIdealPeak(zoneNum, zoneCoolingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(*state, zoneNum, zoneCoolingLatentLoad);
     EXPECT_EQ(1000.0, c2->rmLatentAtPeak);
     zoneNum = 3;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadCoolingIdealPeak(zoneNum, zoneCoolingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(*state, zoneNum, zoneCoolingLatentLoad);
     EXPECT_EQ(2000.0, c2->rmLatentAtPeak);
 
     // Add a heating coil
     std::string coil3Name("Coil 3");                // user-defined name of the coil
-    std::string coil3Type("Coil:Heating:Electric"); // idf input object class name of coil
+    HVAC::CoilType coil3Type = HVAC::CoilType::HeatingElectric;
     uA = -999.0;
     sizingCap = 500.0;
     curSysNum = 1;
     curZoneEqNum = 0;
     isAutoSized = false; // true if autosized
     // This triggers doAirLoopSetUp
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilUA(*state, coil3Name, coil3Type, uA, sizingCap, isAutoSized, curSysNum, curZoneEqNum);
-    auto &c3(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[2]);
+    ReportCoilSelection::setCoilUA(*state, coil3Name, coil3Type, uA, sizingCap, isAutoSized, curSysNum, curZoneEqNum);
+    auto *c3 = state->dataRptCoilSelection->coils[2];
     EXPECT_EQ(uA, c3->coilUA);
     EXPECT_EQ(sizingCap, c3->coilTotCapAtPeak);
     EXPECT_EQ(curSysNum, c3->airloopNum);
@@ -210,23 +209,23 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ChWCoil)
     // This coil serves zones 2 and 3 - rmLatentAtPeak is summed for all applicable zones
     Real64 zoneHeatingLatentLoad = 100.0;
     zoneNum = 1;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadHeatingIdealPeak(zoneNum, zoneHeatingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(*state, zoneNum, zoneHeatingLatentLoad);
     EXPECT_EQ(0.0, c3->rmLatentAtPeak);
     zoneNum = 2;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadHeatingIdealPeak(zoneNum, zoneHeatingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(*state, zoneNum, zoneHeatingLatentLoad);
     EXPECT_EQ(100.0, c3->rmLatentAtPeak);
     zoneNum = 3;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadHeatingIdealPeak(zoneNum, zoneHeatingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(*state, zoneNum, zoneHeatingLatentLoad);
     EXPECT_EQ(200.0, c3->rmLatentAtPeak);
 
     // Exercise report writing again
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 }
 
 TEST_F(EnergyPlusFixture, ReportCoilSelection_SteamCoil)
 {
     std::string coil1Name("Coil 1");             // user-defined name of the coil
-    std::string coil1Type("Coil:Heating:Steam"); // idf input object class name of coil
+    HVAC::CoilType coil1Type = HVAC::CoilType::HeatingSteam; 
     int wInletNodeNum = 9;
     int wOutletNodeNum = 15;
 
@@ -256,10 +255,10 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_SteamCoil)
 
     Real64 airVdot(0.052);   // air flow rate in m3/s
     bool isAutoSized(false); // true if autosized
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(*state, coil1Name, coil1Type, airVdot, isAutoSized);
-    auto &c1(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0]);
+    ReportCoilSelection::setCoilAirFlow(*state, coil1Name, coil1Type, airVdot, isAutoSized);
+    auto *c1 = state->dataRptCoilSelection->coils[0];
     EXPECT_EQ(coil1Name, c1->coilName_);
-    EXPECT_EQ(coil1Type, c1->coilObjName);
+    EXPECT_ENUM_EQ(coil1Type, c1->coilType);
     EXPECT_EQ(airVdot, c1->coilDesVolFlow);
     EXPECT_EQ(isAutoSized, c1->volFlowIsAutosized);
 
@@ -267,8 +266,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_SteamCoil)
     Real64 waterVdot = 0.05;
     // First with no plant sizing objects defined
     isAutoSized = false; // true if autosized
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(
-        *state, coil1Name, coil1Type, waterVdot, isAutoSized, wInletNodeNum, wOutletNodeNum, loopNum);
+    ReportCoilSelection::setCoilWaterFlowNodeNums(*state, coil1Name, coil1Type, waterVdot, isAutoSized, wInletNodeNum, wOutletNodeNum, loopNum);
     EXPECT_EQ(-999, c1->pltSizNum);
     EXPECT_EQ(loopNum, c1->waterLoopNum);
     EXPECT_EQ(state->dataPlnt->PlantLoop(1).Name, c1->plantLoopName);
@@ -283,9 +281,8 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_SteamCoil)
     state->dataSize->PlantSizData(1).PlantLoopName = "Steam Loop";
     state->dataSize->PlantSizData(1).LoopType = DataSizing::TypeOfPlantLoop::Steam;
     isAutoSized = true; // true if autosized
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(
-        *state, coil1Name, coil1Type, waterVdot, isAutoSized, wInletNodeNum, wOutletNodeNum, loopNum);
-    auto &c1b(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0]);
+    ReportCoilSelection::setCoilWaterFlowNodeNums(*state, coil1Name, coil1Type, waterVdot, isAutoSized, wInletNodeNum, wOutletNodeNum, loopNum);
+    auto *c1b = state->dataRptCoilSelection->coils[0];
     EXPECT_EQ(1, c1b->pltSizNum);
     EXPECT_EQ(loopNum, c1b->waterLoopNum);
     EXPECT_EQ(state->dataPlnt->PlantLoop(1).Name, c1b->plantLoopName);
@@ -296,13 +293,13 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_SteamCoil)
     EXPECT_EQ("Yes", c1b->coilWaterFlowAutoMsg);
 
     // Exercise report writing again
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 }
 
 TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
 {
     std::string coil1Name("Coil 1");            // user-defined name of the coil
-    std::string coil1Type("Coil:Heating:Fuel"); // idf input object class name of coil
+    HVAC::CoilType coil1Type = HVAC::CoilType::HeatingGasOrOtherFuel;
 
     state->dataGlobal->NumOfZones = 3;
     state->dataHeatBal->Zone.allocate(state->dataGlobal->NumOfZones);
@@ -331,9 +328,8 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
     Real64 airFlowRate = 0.11;
     Real64 waterFlowRate = 0.0;
 
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(
-        *state, coil1Name, coil1Type, totGrossCap, sensGrossCap, airFlowRate, waterFlowRate);
-    auto &c1(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0]);
+    ReportCoilSelection::setCoilFinalSizes(*state, coil1Name, coil1Type, totGrossCap, sensGrossCap, airFlowRate, waterFlowRate);
+    auto *c1 = state->dataRptCoilSelection->coils[0];
     EXPECT_EQ(totGrossCap, c1->coilTotCapFinal);
     EXPECT_EQ(sensGrossCap, c1->coilSensCapFinal);
     EXPECT_EQ(airFlowRate, c1->coilRefAirVolFlowFinal);
@@ -354,7 +350,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
     Real64 RatedCoilEff = 0.8;
 
     // First without setting coil inlet/outlet conditions
-    state->dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(*state,
+    ReportCoilSelection::setRatedCoilConditions(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -393,7 +389,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
     RatedCoilInHumRat = 0.008;
     RatedCoilOutDb = 40.0;
     RatedCoilOutHumRat = 0.009;
-    state->dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(*state,
+    ReportCoilSelection::setRatedCoilConditions(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -417,48 +413,48 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
     EXPECT_NEAR(63371.3, c1->ratedCoilOutEnth, 0.1);
 
     Real64 entAirDryBulbTemp = 24.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
+    ReportCoilSelection::setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
     EXPECT_EQ(entAirDryBulbTemp, c1->coilDesEntTemp);
     EXPECT_EQ(curSysNum, c1->airloopNum);
     EXPECT_EQ(curZoneEqNum, c1->zoneEqNum);
 
     Real64 entAirHumRat = 0.004;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(*state, coil1Name, coil1Type, entAirHumRat);
+    ReportCoilSelection::setCoilEntAirHumRat(*state, coil1Name, coil1Type, entAirHumRat);
     EXPECT_EQ(entAirHumRat, c1->coilDesEntHumRat);
 
     Real64 entWaterTemp = 60.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(*state, coil1Name, coil1Type, entWaterTemp);
+    ReportCoilSelection::setCoilEntWaterTemp(*state, coil1Name, coil1Type, entWaterTemp);
     EXPECT_EQ(entWaterTemp, c1->coilDesWaterEntTemp);
 
     Real64 lvgWaterTemp = 50.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(*state, coil1Name, coil1Type, lvgWaterTemp);
+    ReportCoilSelection::setCoilLvgWaterTemp(*state, coil1Name, coil1Type, lvgWaterTemp);
     EXPECT_EQ(lvgWaterTemp, c1->coilDesWaterLvgTemp);
 
     Real64 CoilWaterDeltaT = 50.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(*state, coil1Name, coil1Type, CoilWaterDeltaT);
+    ReportCoilSelection::setCoilWaterDeltaT(*state, coil1Name, coil1Type, CoilWaterDeltaT);
     EXPECT_EQ(CoilWaterDeltaT, c1->coilDesWaterTempDiff);
 
     Real64 lvgAirDryBulbTemp = 12.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
+    ReportCoilSelection::setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
     EXPECT_EQ(lvgAirDryBulbTemp, c1->coilDesLvgTemp);
 
     Real64 lvgAirHumRat = 0.006;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(*state, coil1Name, coil1Type, lvgAirHumRat);
+    ReportCoilSelection::setCoilLvgAirHumRat(*state, coil1Name, coil1Type, lvgAirHumRat);
     EXPECT_EQ(lvgAirHumRat, c1->coilDesLvgHumRat);
 
     int zoneNum = 1;
     Real64 zoneCoolingLatentLoad = 1234.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadCoolingIdealPeak(zoneNum, zoneCoolingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(*state, zoneNum, zoneCoolingLatentLoad);
     // Expect zero because it's a heating coil
     EXPECT_EQ(0.0, c1->rmLatentAtPeak);
 
     Real64 zoneHeatingLatentLoad = 4321.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadHeatingIdealPeak(zoneNum, zoneHeatingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(*state, zoneNum, zoneHeatingLatentLoad);
     // Expect zero because doZoneEqSetup isn't currently executed
     EXPECT_EQ(0.0, c1->rmLatentAtPeak);
 
     // Exercise report writing again
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 
     // Test coil reporting
     curZoneEqNum = 1;
@@ -488,7 +484,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
     state->dataSize->DataFlowUsedForSizing = airFlowRate / state->dataEnvrn->StdRhoAir;
 
     // setCoilHeatingCapacity will not overwrite previously set temperature data
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(*state,
+    ReportCoilSelection::setCoilHeatingCapacity(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -502,15 +498,15 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
                                                                                 DXFlowPerCapMaxRatio);
     EXPECT_EQ(entAirDryBulbTemp, c1->coilDesEntTemp);
 
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadHeatingIdealPeak(zoneNum, zoneHeatingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(*state, zoneNum, zoneHeatingLatentLoad);
     // Expect non-zero because this is a heating coil
     EXPECT_LT(0.0, zoneHeatingLatentLoad);
     EXPECT_NEAR(zoneHeatingLatentLoad, c1->rmLatentAtPeak, 0.000001);
 
     entAirDryBulbTemp = 21.0; // change coil entering air temp
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
+    ReportCoilSelection::setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
     lvgAirDryBulbTemp = 30.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
+    ReportCoilSelection::setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
     EXPECT_EQ(entAirDryBulbTemp, c1->coilDesEntTemp);
     EXPECT_EQ(lvgAirDryBulbTemp, c1->coilDesLvgTemp);
 
@@ -521,7 +517,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
     c1->coilDesEntHumRat = -999.0;
     c1->coilDesLvgTemp = -999.0;
     c1->coilDesLvgHumRat = -999.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(*state,
+    ReportCoilSelection::setCoilHeatingCapacity(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -544,7 +540,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
     EXPECT_NEAR(RatedCoilTotCap, c1->coilTotCapAtPeak, 0.000001);
     // test heating capacity adjustment with a CapFT curve
     coilCapFunTempFac = 1.15;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(*state,
+    ReportCoilSelection::setCoilHeatingCapacity(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -563,7 +559,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoil)
 TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
 {
     std::string coil1Name("Coil 1");          // user-defined name of the coil
-    std::string coil1Type("Coil:Cooling:DX"); // idf input object class name of coil
+    HVAC::CoilType coil1Type = HVAC::CoilType::CoolingDX;
 
     state->dataGlobal->NumOfZones = 3;
     state->dataHeatBal->Zone.allocate(state->dataGlobal->NumOfZones);
@@ -592,9 +588,8 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
     Real64 airFlowRate = 0.11;
     Real64 waterFlowRate = 0.0;
 
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(
-        *state, coil1Name, coil1Type, totGrossCap, sensGrossCap, airFlowRate, waterFlowRate);
-    auto &c1(state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0]);
+    ReportCoilSelection::setCoilFinalSizes(*state, coil1Name, coil1Type, totGrossCap, sensGrossCap, airFlowRate, waterFlowRate);
+    auto *c1 = state->dataRptCoilSelection->coils[0];
     EXPECT_EQ(totGrossCap, c1->coilTotCapFinal);
     EXPECT_EQ(sensGrossCap, c1->coilSensCapFinal);
     EXPECT_EQ(airFlowRate, c1->coilRefAirVolFlowFinal);
@@ -615,7 +610,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
     Real64 RatedCoilEff = 0.8;
 
     // First without setting coil inlet/outlet conditions
-    state->dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(*state,
+    ReportCoilSelection::setRatedCoilConditions(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -654,7 +649,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
     RatedCoilInHumRat = 0.008;
     RatedCoilOutDb = 12.0;
     RatedCoilOutHumRat = 0.006;
-    state->dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(*state,
+    ReportCoilSelection::setRatedCoilConditions(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -678,36 +673,36 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
     EXPECT_NEAR(27197.5, c1->ratedCoilOutEnth, 0.1);
 
     Real64 entAirDryBulbTemp = 24.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
+    ReportCoilSelection::setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
     EXPECT_EQ(entAirDryBulbTemp, c1->coilDesEntTemp);
     EXPECT_EQ(curSysNum, c1->airloopNum);
     EXPECT_EQ(curZoneEqNum, c1->zoneEqNum);
 
     Real64 entAirHumRat = 0.004;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(*state, coil1Name, coil1Type, entAirHumRat);
+    ReportCoilSelection::setCoilEntAirHumRat(*state, coil1Name, coil1Type, entAirHumRat);
     EXPECT_EQ(entAirHumRat, c1->coilDesEntHumRat);
 
     Real64 lvgAirDryBulbTemp = 14.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
+    ReportCoilSelection::setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
     EXPECT_EQ(lvgAirDryBulbTemp, c1->coilDesLvgTemp);
 
     Real64 lvgAirHumRat = 0.005;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(*state, coil1Name, coil1Type, lvgAirHumRat);
+    ReportCoilSelection::setCoilLvgAirHumRat(*state, coil1Name, coil1Type, lvgAirHumRat);
     EXPECT_EQ(lvgAirHumRat, c1->coilDesLvgHumRat);
 
     int zoneNum = 1;
     Real64 zoneCoolingLatentLoad = 1234.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadCoolingIdealPeak(zoneNum, zoneCoolingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(*state, zoneNum, zoneCoolingLatentLoad);
     // Expect zero because doZoneEqSetup isn't currently executed
     EXPECT_EQ(0.0, c1->rmLatentAtPeak);
 
     Real64 zoneHeatingLatentLoad = 4321.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadHeatingIdealPeak(zoneNum, zoneHeatingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadHeatingIdealPeak(*state, zoneNum, zoneHeatingLatentLoad);
     // Expect zero because doZoneEqSetup isn't currently executed
     EXPECT_EQ(0.0, c1->rmLatentAtPeak);
 
     // Exercise report writing again
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 
     // Test coil reporting
     curZoneEqNum = 1;
@@ -732,7 +727,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
     state->dataSize->DataFlowUsedForSizing = airFlowRate / state->dataEnvrn->StdRhoAir;
 
     // setCoilCoolingCapacity will not overwrite previously set temperature data
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(*state,
+    ReportCoilSelection::setCoilCoolingCapacity(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -752,14 +747,14 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
     EXPECT_EQ(CpMoistAir, c1->cpMoistAir);
     EXPECT_NEAR(c1->fanHeatGainIdealPeak, fanHeatGain, 0.000001);
 
-    state->dataRptCoilSelection->coilSelectionReportObj->setZoneLatentLoadCoolingIdealPeak(zoneNum, zoneCoolingLatentLoad);
+    ReportCoilSelection::setZoneLatentLoadCoolingIdealPeak(*state, zoneNum, zoneCoolingLatentLoad);
     // Expect non-zero zone cooling latent load
     EXPECT_EQ(zoneCoolingLatentLoad, c1->rmLatentAtPeak);
 
     entAirDryBulbTemp = 21.0; // change coil entering air temp
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
+    ReportCoilSelection::setCoilEntAirTemp(*state, coil1Name, coil1Type, entAirDryBulbTemp, curSysNum, curZoneEqNum);
     lvgAirDryBulbTemp = 12.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
+    ReportCoilSelection::setCoilLvgAirTemp(*state, coil1Name, coil1Type, lvgAirDryBulbTemp);
     EXPECT_EQ(entAirDryBulbTemp, c1->coilDesEntTemp);
     EXPECT_EQ(lvgAirDryBulbTemp, c1->coilDesLvgTemp);
 
@@ -769,7 +764,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
     c1->coilDesEntHumRat = -999.0;
     c1->coilDesLvgTemp = -999.0;
     c1->coilDesLvgHumRat = -999.0;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(*state,
+    ReportCoilSelection::setCoilCoolingCapacity(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -793,7 +788,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
 
     // test cooling capacity adjustment with a CapFT curve != 1
     coilCapFunTempFac = 1.15;
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(*state,
+    ReportCoilSelection::setCoilCoolingCapacity(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -812,7 +807,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_ZoneEqCoolingCoil)
 TEST_F(EnergyPlusFixture, ReportCoilSelection_4PipeFCU_ElecHeatingCoil)
 {
     std::string coil1Name("ElecHeatCoil");          // user-defined name of the coil
-    std::string coil1Type("Coil:Heating:Electric"); // idf input object class name of coil
+    HVAC::CoilType coil1Type = HVAC::CoilType::HeatingElectric; 
 
     state->dataGlobal->NumOfZones = 1;
     state->dataHeatBal->Zone.allocate(state->dataGlobal->NumOfZones);
@@ -837,9 +832,9 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_4PipeFCU_ElecHeatingCoil)
     Real64 airVolFlowRate = 0.1385;
     Real64 waterFlowRate = 0.0;
 
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(
+    ReportCoilSelection::setCoilFinalSizes(
         *state, coil1Name, coil1Type, totGrossCap, sensGrossCap, airVolFlowRate, waterFlowRate);
-    auto &c1 = state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0];
+    auto &c1 = state->dataRptCoilSelection->coils[0];
 
     EXPECT_EQ(totGrossCap, c1->coilTotCapFinal);
     EXPECT_EQ(sensGrossCap, c1->coilSensCapFinal);
@@ -864,7 +859,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_4PipeFCU_ElecHeatingCoil)
     Real64 result_coilDesEntEnth = Psychrometrics::PsyHFnTdbW(RatedCoilInDb, RatedCoilInHumRat);
     Real64 result_coilDesOutEnth = Psychrometrics::PsyHFnTdbW(RatedCoilOutDb, RatedCoilOutHumRat);
     // set coil inlet/outlet conditions
-    state->dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(*state,
+    ReportCoilSelection::setRatedCoilConditions(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -926,7 +921,7 @@ TEST_F(EnergyPlusFixture, ReportCoilSelection_4PipeFCU_ElecHeatingCoil)
     c1->coilDesLvgTemp = -999.0;
     c1->coilDesLvgHumRat = -999.0;
     // check setCoilHeatingCapacity calculations and coil conditions are set correctly
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(*state,
+    ReportCoilSelection::setCoilHeatingCapacity(*state,
                                                                                 coil1Name,
                                                                                 coil1Type,
                                                                                 RatedCoilTotCap,
@@ -958,13 +953,11 @@ TEST_F(EnergyPlusFixture, Test_finishCoilSummaryReportTable)
     int curOASysNum = 0;
     int curZoneEqNum = 1;
     std::string coil1Name = "ElecHeatCoil";          // user-defined name of the coil
-    std::string coil1Type = "Coil:Heating:Electric"; // idf input object class name of coil
+    HVAC::CoilType coil1Type = HVAC::CoilType::HeatingElectric; // idf input object class name of coil
 
     // set up coil selection report object by calling a public function (i.e., calls getIndexForOrCreateDataObjFromCoilName)
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(*state, coil1Name, coil1Type, mult);
-    bool isValidCoilType = state->dataRptCoilSelection->coilSelectionReportObj->isCompTypeCoil(coil1Type);
-    EXPECT_TRUE(isValidCoilType);
-    auto &c1 = state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0];
+    ReportCoilSelection::setCoilReheatMultiplier(*state, coil1Name, coil1Type, mult);
+    auto *c1 = state->dataRptCoilSelection->coils[0];
     c1->zoneEqNum = curZoneEqNum;
 
     state->dataHeatBal->Zone.allocate(1);
@@ -993,7 +986,7 @@ TEST_F(EnergyPlusFixture, Test_finishCoilSummaryReportTable)
     EXPECT_TRUE(Util::SameString(c1->typeHVACname, "unknown"));
     EXPECT_TRUE(Util::SameString(c1->userNameforHVACsystem, "unknown"));
 
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 
     EXPECT_TRUE(Util::SameString(c1->coilLocation, "Zone Equipment"));
     EXPECT_TRUE(Util::SameString(c1->typeHVACname, "ZoneHVAC:FourPipeFanCoil"));
@@ -1015,7 +1008,7 @@ TEST_F(EnergyPlusFixture, Test_finishCoilSummaryReportTable)
 
     // test that 2 equipment in the equipment list will fill coil selection data
     std::string coil2Name = "ElecHeatCoil 2";        // user-defined name of the coil
-    std::string coil2Type = "Coil:Heating:Electric"; // idf input object class name of coil
+    HVAC::CoilType coil2Type = HVAC::CoilType::HeatingElectric;
 
     zoneEquipList.EquipName(1) = "Zone 1 FCU";
     zoneEquipList.EquipTypeName(1) = "ZoneHVAC:FourPipeFanCoil";
@@ -1039,16 +1032,16 @@ TEST_F(EnergyPlusFixture, Test_finishCoilSummaryReportTable)
     zoneEquipList.EquipData(2).SubEquipData(1).SubSubEquipData(1).Name = coil2Name;
 
     // set up coil selection report object by calling a public function that calls getIndexForOrCreateDataObjFromCoilName
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(*state, coil2Name, coil2Type, mult);
-    auto &c1a = state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0];
-    auto &c2a = state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[1];
+    ReportCoilSelection::setCoilReheatMultiplier(*state, coil2Name, coil2Type, mult);
+    auto *c1a = state->dataRptCoilSelection->coils[0];
+    auto *c2a = state->dataRptCoilSelection->coils[1];
     c2a->zoneEqNum = curZoneEqNum;
 
     EXPECT_TRUE(Util::SameString(c2a->coilLocation, "unknown"));
     EXPECT_TRUE(Util::SameString(c2a->typeHVACname, "unknown"));
     EXPECT_TRUE(Util::SameString(c2a->userNameforHVACsystem, "unknown"));
 
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 
     EXPECT_TRUE(Util::SameString(c1a->coilLocation, "Zone Equipment"));
     EXPECT_TRUE(Util::SameString(c1a->typeHVACname, "ZoneHVAC:FourPipeFanCoil"));
@@ -1071,15 +1064,14 @@ TEST_F(EnergyPlusFixture, Test_finishCoilSummaryReportTable)
     EXPECT_TRUE(Util::SameString(zoneEquipList.EquipData(2).SubEquipData(1).SubSubEquipData(1).Name, coil2Name));
 
     // delete coil report objects to start from scratch
-    state->dataRptCoilSelection->coilSelectionReportObj->numCoilsReported_ = 0;
-    state->dataRptCoilSelection->coilSelectionReportObj.reset(nullptr);
-    createCoilSelectionReportObj(*state);
-
+    for (int i = 0; i < state->dataRptCoilSelection->coils.size(); ++i) delete state->dataRptCoilSelection->coils[i];
+    state->dataRptCoilSelection->coils.clear();
+    
     // switch coil order in coil reports to try to find issues
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(*state, coil2Name, coil2Type, mult);
-    state->dataRptCoilSelection->coilSelectionReportObj->setCoilReheatMultiplier(*state, coil1Name, coil1Type, mult);
-    auto &c1b = state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[0];
-    auto &c2b = state->dataRptCoilSelection->coilSelectionReportObj->coilSelectionDataObjs[1];
+    ReportCoilSelection::setCoilReheatMultiplier(*state, coil2Name, coil2Type, mult);
+    ReportCoilSelection::setCoilReheatMultiplier(*state, coil1Name, coil1Type, mult);
+    auto *c1b = state->dataRptCoilSelection->coils[0];
+    auto *c2b = state->dataRptCoilSelection->coils[1];
     c1b->zoneEqNum = curZoneEqNum;
     c2b->zoneEqNum = curZoneEqNum;
 
@@ -1105,7 +1097,7 @@ TEST_F(EnergyPlusFixture, Test_finishCoilSummaryReportTable)
     EXPECT_ENUM_EQ(zoneEquipList.EquipType(2), DataZoneEquipment::ZoneEquipType::FourPipeFanCoil);
     EXPECT_TRUE(Util::SameString(zoneEquipList.EquipData(2).SubEquipData(1).Name, coil1Name));
 
-    state->dataRptCoilSelection->coilSelectionReportObj->finishCoilSummaryReportTable(*state);
+    ReportCoilSelection::finishCoilSummaryReportTable(*state);
 
     EXPECT_TRUE(Util::SameString(c1b->coilLocation, "Zone Equipment"));
     EXPECT_TRUE(Util::SameString(c1b->typeHVACname, "ZoneHVAC:AirDistributionUnit"));
diff --git a/tst/EnergyPlus/unit/SZVAVModel.unit.cc b/tst/EnergyPlus/unit/SZVAVModel.unit.cc
index cf7d0e3d185..14af7f13df9 100644
--- a/tst/EnergyPlus/unit/SZVAVModel.unit.cc
+++ b/tst/EnergyPlus/unit/SZVAVModel.unit.cc
@@ -180,10 +180,12 @@ TEST_F(EnergyPlusFixture, SZVAV_PTUnit_Testing)
     UnitarySystems::UnitarySys thisUnit;
     int FanIndex = Fans::GetFanIndex(*state, "TEST FAN");
     thisUnit.AirInNode = state->dataFans->fans(FanIndex)->inletNodeNum;
-    thisUnit.CoolCoilInletNodeNum = DXCoils::GetCoilInletNode(*state, "Coil:Cooling:DX:SingleSpeed", "COOLINGCOIL", errFlag);
-    thisUnit.CoolCoilOutletNodeNum = DXCoils::GetCoilOutletNode(*state, "Coil:Cooling:DX:SingleSpeed", "COOLINGCOIL", errFlag);
+    int coolCoilNum = DXCoils::GetCoilIndex(*state, "COOLINGCOIL");
+    thisUnit.CoolCoilInletNodeNum = DXCoils::GetCoilAirInletNode(*state, coolCoilNum);
+    thisUnit.CoolCoilOutletNodeNum = DXCoils::GetCoilAirOutletNode(*state, coolCoilNum);
     thisUnit.HeatCoilInletNodeNum = thisUnit.CoolCoilOutletNodeNum;
-    thisUnit.HeatCoilOutletNodeNum = DXCoils::GetCoilOutletNode(*state, "Coil:Heating:DX:SingleSpeed", "HEATINGCOIL", errFlag);
+    int heatCoilNum = DXCoils::GetCoilIndex(*state, "HEATINGCOIL");
+    thisUnit.HeatCoilOutletNodeNum = DXCoils::GetCoilAirOutletNode(*state, heatCoilNum);
     thisUnit.AirOutNode = thisUnit.HeatCoilOutletNodeNum;
     // set zone condition
     int zoneNodeNum = NodeInputManager::GetOnlySingleNode(*state,
@@ -240,12 +242,12 @@ TEST_F(EnergyPlusFixture, SZVAV_PTUnit_Testing)
     thisUnit.m_sysType = UnitarySystems::UnitarySys::SysType::Unitary;
     thisUnit.m_FanName = "TEST FAN";
     thisUnit.m_FanType = HVAC::FanType::OnOff;
-    thisUnit.m_CoolingCoilName = "COOLINGCOIL";
-    thisUnit.m_HeatingCoilName = "HEATINGCOIL";
-    thisUnit.m_CoolingCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
-    thisUnit.m_HeatingCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
-    thisUnit.m_CoolingCoilIndex = 1;
-    thisUnit.m_HeatingCoilIndex = 2;
+    thisUnit.m_CoolCoilName = "COOLINGCOIL";
+    thisUnit.m_HeatCoilName = "HEATINGCOIL";
+    thisUnit.m_coolCoilType = HVAC::CoilType::CoolingDXSingleSpeed;
+    thisUnit.m_heatCoilType = HVAC::CoilType::HeatingDXSingleSpeed;
+    thisUnit.m_CoolCoilNum = 1;
+    thisUnit.m_HeatCoilNum = 2;
     thisUnit.m_FanIndex = 1;
     thisUnit.m_sysAvailSched = Sched::GetSchedule(*state, "ONSCHED");
     thisUnit.m_fanAvailSched = Sched::GetSchedule(*state, "ONSCHED");
@@ -270,7 +272,6 @@ TEST_F(EnergyPlusFixture, SZVAV_PTUnit_Testing)
     state->dataEnvrn->OutDryBulbTemp = 30.0;
     state->dataEnvrn->OutBaroPress = 101325.0;
     OutputReportPredefined::SetPredefinedTables(*state);
-    createCoilSelectionReportObj(*state);
 
     int UnitNum = 0;
     bool FirstHVACIteration = true;
@@ -657,9 +658,9 @@ TEST_F(EnergyPlusFixture, SZVAV_FanCoilUnit_Testing)
     auto &thisFanCoil(state->dataFanCoilUnits->FanCoil(1));
     EXPECT_ENUM_EQ(CCM::ASHRAE, thisFanCoil.CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", thisFanCoil.OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)thisFanCoil.fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", thisFanCoil.CCoilType);
-    EXPECT_EQ("COIL:HEATING:ELECTRIC", thisFanCoil.HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, thisFanCoil.fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisFanCoil.coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingElectric, thisFanCoil.heatCoilType);
     state->dataPlnt->TotNumLoops = 1;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
     AirMassFlow = 0.60;
diff --git a/tst/EnergyPlus/unit/SecondaryDXCoils.unit.cc b/tst/EnergyPlus/unit/SecondaryDXCoils.unit.cc
index 010414d99c8..db5d37c1b7e 100644
--- a/tst/EnergyPlus/unit/SecondaryDXCoils.unit.cc
+++ b/tst/EnergyPlus/unit/SecondaryDXCoils.unit.cc
@@ -80,7 +80,7 @@ TEST_F(EnergyPlusFixture, SecondaryDXCoolingCoilSingleSpeed_Test1)
     DXCoilNum = 1;
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
     state->dataDXCoils->DXCoil(DXCoilNum).IsSecondaryDXCoilInZone = true;
-    state->dataDXCoils->DXCoil(DXCoilNum).DXCoilType_Num = HVAC::CoilDX_CoolingSingleSpeed;
+    state->dataDXCoils->DXCoil(DXCoilNum).coilType = HVAC::CoilType::CoolingDXSingleSpeed;
     state->dataDXCoils->DXCoil(DXCoilNum).TotalCoolingEnergyRate = 5000.0;
     state->dataDXCoils->DXCoil(DXCoilNum).ElecCoolingPower = 500.0;
     state->dataDXCoils->DXCoil(DXCoilNum).SecCoilSensibleHeatGainRate = 0.0;
@@ -103,7 +103,7 @@ TEST_F(EnergyPlusFixture, SecondaryDXCoolingCoilTwoSpeed_Test2)
     DXCoilNum = 1;
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
     state->dataDXCoils->DXCoil(DXCoilNum).IsSecondaryDXCoilInZone = true;
-    state->dataDXCoils->DXCoil(DXCoilNum).DXCoilType_Num = HVAC::CoilDX_CoolingTwoSpeed;
+    state->dataDXCoils->DXCoil(DXCoilNum).coilType = HVAC::CoilType::CoolingDXTwoSpeed;
     state->dataDXCoils->DXCoil(DXCoilNum).TotalCoolingEnergyRate = 5000.0;
     state->dataDXCoils->DXCoil(DXCoilNum).ElecCoolingPower = 500.0;
     state->dataDXCoils->DXCoil(DXCoilNum).SecCoilSensibleHeatGainRate = 0.0;
@@ -126,7 +126,7 @@ TEST_F(EnergyPlusFixture, SecondaryDXCoolingCoilMultiSpeed_Test3)
     DXCoilNum = 1;
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
     state->dataDXCoils->DXCoil(DXCoilNum).IsSecondaryDXCoilInZone = true;
-    state->dataDXCoils->DXCoil(DXCoilNum).DXCoilType_Num = HVAC::CoilDX_MultiSpeedCooling;
+    state->dataDXCoils->DXCoil(DXCoilNum).coilType = HVAC::CoilType::CoolingDXMultiSpeed;
     state->dataDXCoils->DXCoil(DXCoilNum).TotalCoolingEnergyRate = 5000.0;
     state->dataDXCoils->DXCoil(DXCoilNum).ElecCoolingPower = 500.0;
     state->dataDXCoils->DXCoil(DXCoilNum).SecCoilSensibleHeatGainRate = 0.0;
@@ -149,7 +149,7 @@ TEST_F(EnergyPlusFixture, SecondaryDXHeatingCoilSingleSpeed_Test4)
     DXCoilNum = 1;
     state->dataDXCoils->DXCoil.allocate(state->dataDXCoils->NumDXCoils);
     state->dataDXCoils->DXCoil(DXCoilNum).IsSecondaryDXCoilInZone = true;
-    state->dataDXCoils->DXCoil(DXCoilNum).DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    state->dataDXCoils->DXCoil(DXCoilNum).coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     state->dataDXCoils->DXCoil(DXCoilNum).MinOATCompressor = -5.0;
     state->dataDXCoils->DXCoil(DXCoilNum).TotalHeatingEnergyRate = 5500.0;
     state->dataDXCoils->DXCoil(DXCoilNum).ElecHeatingPower = 500.0;
@@ -231,7 +231,7 @@ TEST_F(EnergyPlusFixture, SecondaryDXHeatingCoilMultiSpeed_Test5)
     state->dataDXCoils->DXCoil(DXCoilNum).MSSecCoilSHRFF.allocate(state->dataDXCoils->DXCoil(DXCoilNum).NumOfSpeeds);
 
     state->dataDXCoils->DXCoil(DXCoilNum).IsSecondaryDXCoilInZone = true;
-    state->dataDXCoils->DXCoil(DXCoilNum).DXCoilType_Num = HVAC::CoilDX_MultiSpeedHeating;
+    state->dataDXCoils->DXCoil(DXCoilNum).coilType = HVAC::CoilType::HeatingDXMultiSpeed;
     state->dataDXCoils->DXCoil(DXCoilNum).MinOATCompressor = -5.0;
     state->dataDXCoils->DXCoil(DXCoilNum).TotalHeatingEnergyRate = 5500.0;
     state->dataDXCoils->DXCoil(DXCoilNum).ElecHeatingPower = 500.0;
diff --git a/tst/EnergyPlus/unit/SingleDuct.unit.cc b/tst/EnergyPlus/unit/SingleDuct.unit.cc
index cc89e3506a0..82d1ec4c1e3 100644
--- a/tst/EnergyPlus/unit/SingleDuct.unit.cc
+++ b/tst/EnergyPlus/unit/SingleDuct.unit.cc
@@ -3110,7 +3110,8 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit)
     sdat(1).zoneMinAirFracSched = schA;
     sdat(1).MaxAirVolFlowRateDuringReheat = 0.25;
     sdat(1).OARequirementsPtr = 0;
-    sdat(1).ReheatComp = "watercoil";
+    sdat(1).ReheatCoilName = "watercoil";
+    sdat(1).reheatCoilType = HVAC::CoilType::CoolingWater;
     sdat(1).fanType = HVAC::FanType::VAV;
     sdat(1).FanName = "FanA";
 
@@ -3128,7 +3129,7 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit)
     EXPECT_EQ("schA", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU a"));
     EXPECT_EQ("0.25", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU a"));
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU a"));
-    EXPECT_EQ("watercoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a"));
+    EXPECT_EQ("Coil:Cooling:Water", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU a"));
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU a"));
     EXPECT_EQ("Fan:VariableVolume", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU a"));
     EXPECT_EQ("FanA", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU a"));
@@ -3149,7 +3150,8 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit)
     sdat(2).zoneMinAirFracSched = nullptr;
     sdat(2).MaxAirVolFlowRateDuringReheat = 0.26;
     sdat(2).OARequirementsPtr = 1;
-    sdat(2).ReheatComp = "furncoil";
+    sdat(2).ReheatCoilName = "furncoil";
+    sdat(2).reheatCoilType = HVAC::CoilType::HeatingElectric;
     sdat(2).fanType = HVAC::FanType::OnOff;
     sdat(2).FanName = "FanB";
 
@@ -3171,7 +3173,7 @@ TEST_F(EnergyPlusFixture, SingleDuctAirTerminal_reportTerminalUnit)
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinFlowSch, "ADU b"));
     EXPECT_EQ("0.26", RetrievePreDefTableEntry(*state, orp.pdchAirTermMaxFlowReh, "ADU b"));
     EXPECT_EQ("Constant-1.0", RetrievePreDefTableEntry(*state, orp.pdchAirTermMinOAflowSch, "ADU b"));
-    EXPECT_EQ("furncoil", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU b"));
+    EXPECT_EQ("Coil:Heating:Electric", RetrievePreDefTableEntry(*state, orp.pdchAirTermHeatCoilType, "ADU b"));
     EXPECT_EQ("n/a", RetrievePreDefTableEntry(*state, orp.pdchAirTermCoolCoilType, "ADU b"));
     EXPECT_EQ("Fan:OnOff", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanType, "ADU b"));
     EXPECT_EQ("FanB", RetrievePreDefTableEntry(*state, orp.pdchAirTermFanName, "ADU b"));
diff --git a/tst/EnergyPlus/unit/StandardRatings.unit.cc b/tst/EnergyPlus/unit/StandardRatings.unit.cc
index 6b93a109e26..e6ddbc90281 100644
--- a/tst/EnergyPlus/unit/StandardRatings.unit.cc
+++ b/tst/EnergyPlus/unit/StandardRatings.unit.cc
@@ -99,8 +99,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedHeatingCoilCurveTest)
     DXCoilData &Coil = state->dataDXCoils->DXCoil(DXCoilNum);
 
     Coil.Name = "DX Single Speed Heating Coil";
-    Coil.DXCoilType = "Coil:Heating:DX:SingleSpeed";
-    Coil.DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    Coil.coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     Coil.availSched = Sched::GetScheduleAlwaysOn(*state);
     Coil.RatedSHR(1) = 1.0;
     Coil.RatedTotCap(1) = 1600.0;
@@ -199,7 +198,8 @@ TEST_F(EnergyPlusFixture, SingleSpeedHeatingCoilCurveTest)
     Real64 HSPF_2023;
     std::map<std::string, Real64> StandardRatingsResults;
     StandardRatingsResults = SingleSpeedDXHeatingCoilStandardRatings(*state,
-                                                                     Coil.DXCoilType,
+                                                                     Coil.Name,
+                                                                     Coil.coilType,
                                                                      Coil.RatedTotCap(1),
                                                                      Coil.RatedCOP(1),
                                                                      Coil.CCapFFlow(1),
@@ -286,8 +286,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedHeatingCoilCurveTest_PositiveCurve)
     DXCoilData &Coil = state->dataDXCoils->DXCoil(DXCoilNum);
 
     Coil.Name = "DX Single Speed Heating Coil";
-    Coil.DXCoilType = "Coil:Heating:DX:SingleSpeed";
-    Coil.DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    Coil.coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     Coil.availSched = Sched::GetScheduleAlwaysOn(*state);
     Coil.RatedSHR(1) = 1.0;
     Coil.RatedTotCap(1) = 1600.0;
@@ -384,7 +383,8 @@ TEST_F(EnergyPlusFixture, SingleSpeedHeatingCoilCurveTest_PositiveCurve)
     Real64 HSPF_2023;
     std::map<std::string, Real64> StandardRatingsResults;
     StandardRatingsResults = SingleSpeedDXHeatingCoilStandardRatings(*state,
-                                                                     Coil.DXCoilType,
+                                                                     Coil.Name,
+                                                                     Coil.coilType,
                                                                      Coil.RatedTotCap(1),
                                                                      Coil.RatedCOP(1),
                                                                      Coil.CCapFFlow(1),
@@ -462,8 +462,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedHeatingCoilCurveTest2023)
     DXCoilData &Coil = state->dataDXCoils->DXCoil(DXCoilNum);
 
     Coil.Name = "HeatingCoilDXSingleSpeedAutosize";
-    Coil.DXCoilType = "Coil:Heating:DX:SingleSpeed";
-    Coil.DXCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    Coil.coilType = HVAC::CoilType::HeatingDXSingleSpeed;
     Coil.availSched = Sched::GetScheduleAlwaysOn(*state);
     Coil.RatedSHR(1) = 1.0;
     Coil.RatedTotCap(1) = 1600.0;
@@ -564,7 +563,8 @@ TEST_F(EnergyPlusFixture, SingleSpeedHeatingCoilCurveTest2023)
     Real64 HSPF_2023;
     std::map<std::string, Real64> StandardRatingsResults;
     StandardRatingsResults = SingleSpeedDXHeatingCoilStandardRatings(*state,
-                                                                     Coil.DXCoilType,
+                                                                     Coil.Name,
+                                                                     Coil.coilType,
                                                                      Coil.RatedTotCap(1),
                                                                      Coil.RatedCOP(1),
                                                                      Coil.CCapFFlow(1),
@@ -723,7 +723,8 @@ TEST_F(EnergyPlusFixture, SingleSpeedHeatingCurveTest2023_II)
     Real64 HSPF_2023;
     std::map<std::string, Real64> StandardRatingsResults;
     StandardRatingsResults = SingleSpeedDXHeatingCoilStandardRatings(*state,
-                                                                     Coil.DXCoilType,
+                                                                     Coil.Name,
+                                                                     Coil.coilType,
                                                                      Coil.RatedTotCap(1),
                                                                      Coil.RatedCOP(1),
                                                                      Coil.CCapFFlow(1),
@@ -956,7 +957,7 @@ TEST_F(EnergyPlusFixture, MultiSpeedHeatingCoil_HSPFValueTest_2Speed)
 
     StandardRatingsResult = MultiSpeedDXHeatingCoilStandardRatings(*state,
                                                                    Coil.Name,          // DXCoilName
-                                                                   Coil.DXCoilType,    // DXCoilType,
+                                                                   Coil.coilType,    // DXCoilType,
                                                                    Coil.MSCCapFTemp,   // CapFTempCurveIndex,
                                                                    Coil.MSCCapFFlow,   // CapFFlowCurveIndex,
                                                                    Coil.MSEIRFTemp,    // EIRFTempCurveIndex,
@@ -1416,7 +1417,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_15000W_SameFanPower_SEER2_2023_
     // calculate standard ratings
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -1469,7 +1470,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_15000W_SameFanPower_SEER2_2023_
     // rerun the standard ratings calculation
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -1517,7 +1518,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_15000W_SameFanPower_SEER2_2023_
     // rerun the standard ratings calculation for PLF Curve (AHRI 2023)
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -1683,7 +1684,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_9000W_SEER2_2023_ValueTest)
     // calculate standard ratings
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -1736,7 +1737,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_9000W_SEER2_2023_ValueTest)
     // rerun the standard ratings calculation
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -1784,7 +1785,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_9000W_SEER2_2023_ValueTest)
     // rerun the standard ratings calculation for PLF Curve (AHRI 2023)
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -1948,7 +1949,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_18000W_SEER2_2023_ValueTest)
     // calculate standard ratings
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -2001,7 +2002,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_18000W_SEER2_2023_ValueTest)
     // rerun the standard ratings calculation
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -2049,7 +2050,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoil_18000W_SEER2_2023_ValueTest)
     // rerun the standard ratings calculation for PLF Curve (AHRI 2023)
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -2206,7 +2207,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoilAir_25000W_IEER_2022_ValueTest)
     Real64 TotCapFlowModFac = Curve::CurveValue(*state, CapFFlowCurveIndex, AirMassFlowRatioRated);
     Real64 EIRFlowModFac = Curve::CurveValue(*state, EIRFFlowCurveIndex, AirMassFlowRatioRated);
     std::tie(IEER_2022, NetCoolingCapRated2022, EER_2022) = IEERCalculationSingleSpeed(*state,
-                                                                                       thisCoil.DXCoilType,
+                                                                                       thisCoil.coilType,
                                                                                        thisCoil.CCapFTemp(1),
                                                                                        thisCoil.RatedTotCap(1),
                                                                                        TotCapFlowModFac,
@@ -2359,7 +2360,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoilEvap_32000W_IEER_2022_ValueTest)
 
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -2506,7 +2507,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoilAir_AHRIExample_IEER_2022_ValueT
 
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -2539,7 +2540,7 @@ TEST_F(EnergyPlusFixture, SingleSpeedCoolingCoilAir_AHRIExample_IEER_2022_ValueT
     thisCoil.FanPowerPerEvapAirFlowRate_2023(1) = 495;
     StandarRatingResults = SingleSpeedDXCoolingCoilStandardRatings(*state,
                                                                    thisCoil.Name,
-                                                                   thisCoil.DXCoilType,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.CCapFTemp(1),
                                                                    thisCoil.CCapFFlow(1),
                                                                    thisCoil.EIRFTemp(1),
@@ -2988,8 +2989,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_02_Speed_4400W_SEER2_2023_ValueT
     Real64 SEER2_Standard(0.0);
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -3043,8 +3044,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_02_Speed_4400W_SEER2_2023_ValueT
     StandardRatingsResult.clear();
     // rerun the standard ratings calculation
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -3098,8 +3099,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_02_Speed_4400W_SEER2_2023_ValueT
     StandardRatingsResult.clear();
     // rerun the standard ratings calculation
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -3585,8 +3586,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_03_Speed_12000W_SEER2_2023_Value
     Real64 SEER2_Standard(0.0);
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -4136,8 +4137,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_04_Speed_17750W_SEER2_2023_Value
     Real64 SEER2_Standard(0.0);
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -4318,8 +4319,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_02_Speeds_27717W_IEER_2022_Value
     std::map<std::string, Real64> StandardRatingsResult;
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -4789,8 +4790,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_03_Speeds_27717W_IEER_2022_Value
     std::map<std::string, Real64> StandardRatingsResult;
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -5297,8 +5298,8 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_04_Speeds_35500W_COP3_IEER_2022_
     std::map<std::string, Real64> StandardRatingsResult;
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = MultiSpeedDXCoolingCoilStandardRatings(*state,
-                                                                   thisCoil.DXCoilType,
                                                                    thisCoil.Name,
+                                                                   thisCoil.coilType,
                                                                    thisCoil.MSCCapFTemp,
                                                                    thisCoil.MSCCapFFlow,
                                                                    thisCoil.MSEIRFTemp,
@@ -5551,7 +5552,7 @@ TEST_F(EnergyPlusFixture, MultiSpeedCoolingCoil_04_Speed_35500W_COP4_IEER_2022_V
     Real64 EER_2022(0.0);
     Real64 NetCoolingCapRated2022(0.0);
     std::tie(IEER_2022, NetCoolingCapRated2022, EER_2022) = IEERCalculationMultiSpeed(*state,
-                                                                                      thisCoil.DXCoilType,
+                                                                                      thisCoil.coilType,
                                                                                       thisCoil.NumOfSpeeds,
                                                                                       thisCoil.MSCCapFTemp,
                                                                                       thisCoil.MSRatedTotCap,
@@ -5685,13 +5686,9 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_01_Speed_7200W_SEER2_2023_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
     auto pLFfPLR_Curve = thisCoil.PLFFPLR;
     auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
     // ckeck user PLF curve coefficients
@@ -5756,8 +5753,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_01_Speed_7200W_SEER2_2023_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -5918,15 +5915,10 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_02_Speed_7200W_SEER2_2023_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -5936,7 +5928,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_02_Speed_7200W_SEER2_2023_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -5989,8 +5981,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_02_Speed_7200W_SEER2_2023_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -6159,15 +6151,9 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_03_Speed_7200W_SEER2_2023_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -6177,7 +6163,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_03_Speed_7200W_SEER2_2023_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -6230,8 +6216,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_03_Speed_7200W_SEER2_2023_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -6413,15 +6399,10 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_7200W_SEER2_2023_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -6431,7 +6412,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_7200W_SEER2_2023_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -6484,8 +6465,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_7200W_SEER2_2023_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -6705,15 +6686,11 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_7200W_SEER2_2023_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
+
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -6723,7 +6700,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_7200W_SEER2_2023_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -6776,8 +6753,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_7200W_SEER2_2023_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -6998,15 +6975,11 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_14400W_SEER2_2023_ValueT
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
+
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -7016,7 +6989,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_14400W_SEER2_2023_ValueT
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -7069,8 +7042,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_14400W_SEER2_2023_ValueT
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -7327,15 +7300,10 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_7200W_SEER2_2023_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -7345,7 +7313,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_7200W_SEER2_2023_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -7398,8 +7366,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_7200W_SEER2_2023_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -7656,14 +7624,9 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_14400W_SEER2_2023_ValueT
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -7673,7 +7636,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_14400W_SEER2_2023_ValueT
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -7727,8 +7690,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_14400W_SEER2_2023_ValueT
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -7867,14 +7830,10 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_01_Speed_22000W_IEER_2022_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "DESICCANT DXSYSTEM VS COOLING COIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.75, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.25, thisCoolPLFfPLR->coeff[1]);
@@ -7884,7 +7843,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_01_Speed_22000W_IEER_2022_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -7933,8 +7892,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_01_Speed_22000W_IEER_2022_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -8122,14 +8081,11 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_02_Speed_36000W_IEER_2022_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "HEAT PUMP ACDXCOIL 1");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
+    
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -8139,7 +8095,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_02_Speed_36000W_IEER_2022_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -8191,8 +8147,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_02_Speed_36000W_IEER_2022_ValueTe
     // calculate standard ratings for multispeed DX cooling coil
     StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -8428,14 +8384,11 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_03_Speed_36000W_IEER_2022_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "HEAT PUMP ACDXCOIL 1");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
+
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -8445,7 +8398,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_03_Speed_36000W_IEER_2022_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -8494,8 +8447,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_03_Speed_36000W_IEER_2022_ValueTe
 
     std::map<std::string, Real64> StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -8696,14 +8649,11 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_36000W_IEER_2022_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "SYS 4 HEAT PUMP AIR SOURCE COOLING COIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
+
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -8713,7 +8663,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_36000W_IEER_2022_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -8762,8 +8712,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_36000W_IEER_2022_ValueTe
 
     std::map<std::string, Real64> StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -8989,14 +8939,11 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_25001W_IEER_2022_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
+
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -9006,7 +8953,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_25001W_IEER_2022_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -9057,8 +9004,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_07_Speed_25001W_IEER_2022_ValueTe
 
     std::map<std::string, Real64> StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -9322,14 +9269,10 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_34582W_IEER_2022_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -9339,7 +9282,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_34582W_IEER_2022_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -9393,8 +9336,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_34582W_IEER_2022_ValueTe
 
     std::map<std::string, Real64> StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -9659,14 +9602,10 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_32000W_IEER_2022_ValueTe
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "ZONE1PTHPDXCOOLCOIL");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType;
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -9676,7 +9615,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_32000W_IEER_2022_ValueTe
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -9727,8 +9666,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_10_Speed_32000W_IEER_2022_ValueTe
 
     std::map<std::string, Real64> StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -10009,14 +9948,11 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_AutoSize_IEER_2022_Value
     EnergyPlus::VariableSpeedCoils::GetVarSpeedCoilInput(*state);
     EXPECT_EQ(state->dataVariableSpeedCoils->VarSpeedCoil(1).Name, "HEAT PUMP ACDXCOIL 1");
     auto &thisCoil(state->dataVariableSpeedCoils->VarSpeedCoil(1));
-    auto condenserType = thisCoil.CondenserType; // Air(0)
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == condenserType);
-    auto varSpeedCoilType = thisCoil.VarSpeedCoilType;
-    EXPECT_EQ(varSpeedCoilType, "Coil:Cooling:DX:VariableSpeed");
-    auto vsCoilType = thisCoil.VSCoilType; // 30
-    EXPECT_TRUE(30 == vsCoilType);
-    auto pLFfPLR_Curve = thisCoil.PLFFPLR;
-    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(pLFfPLR_Curve));
+
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType);
+    EXPECT_ENUM_EQ(thisCoil.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    auto &thisCoolPLFfPLR(state->dataCurveManager->curves(thisCoil.PLFFPLR));
+
     // ckeck user PLF curve coefficients
     EXPECT_EQ(0.85, thisCoolPLFfPLR->coeff[0]);
     EXPECT_EQ(0.15, thisCoolPLFfPLR->coeff[1]);
@@ -10026,7 +9962,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_AutoSize_IEER_2022_Value
     Real64 minEIRfLowPLRXInput(0.0);
     Real64 maxEIRfLowPLRXInput(0.0);
     // check user PLF curve PLR limits
-    Curve::GetCurveMinMaxValues(*state, pLFfPLR_Curve, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
+    Curve::GetCurveMinMaxValues(*state, thisCoil.PLFFPLR, minEIRfLowPLRXInput, maxEIRfLowPLRXInput);
     EXPECT_EQ(0.0, minEIRfLowPLRXInput);
     EXPECT_EQ(1.0, maxEIRfLowPLRXInput);
 
@@ -10075,8 +10011,8 @@ TEST_F(EnergyPlusFixture, VariableSpeedCooling_04_Speed_AutoSize_IEER_2022_Value
 
     std::map<std::string, Real64> StandardRatingsResult = VariableSpeedDXCoolingCoilStandardRatings(
         *state,
-        thisCoil.VarSpeedCoilType, // thisCoil.DXCoilType,
         thisCoil.Name,
+        thisCoil.coilType, // thisCoil.DXCoilType,
         thisCoil.MSCCapFTemp,
         thisCoil.MSCCapAirFFlow, // thisCoil.MSCCapFFlow,
         thisCoil.MSEIRFTemp,
@@ -10302,10 +10238,10 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_18000W_SEER2_2023_ValueTest)
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023(1), 0.01);
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023_LowSpeed(1), 0.01);
 
-    EXPECT_EQ("Coil:Cooling:DX:TwoSpeed", thisCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXTwoSpeed, thisCoil.coilType);
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == thisCoil.CondenserType(1));
-    EXPECT_FALSE(DataHeatBalance::RefrigCondenserType::Evap == thisCoil.CondenserType(1));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType(1));
+    EXPECT_ENUM_NE(DataHeatBalance::RefrigCondenserType::Evap, thisCoil.CondenserType(1));
 
     // Ckeck user curve coefficients
 
@@ -10593,9 +10529,9 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_12000W_SEER2_2023_ValueTest)
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023(1), 0.01);
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023_LowSpeed(1), 0.01);
 
-    EXPECT_EQ("Coil:Cooling:DX:TwoSpeed", thisCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXTwoSpeed, thisCoil.coilType);
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == thisCoil.CondenserType(1));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType(1));
     EXPECT_FALSE(DataHeatBalance::RefrigCondenserType::Evap == thisCoil.CondenserType(1));
 
     // Ckeck user curve coefficients
@@ -10632,8 +10568,7 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_12000W_SEER2_2023_ValueTest)
 
     std::map<std::string, Real64> StandardRatingsResult = TwoSpeedDXCoilStandardRatings(*state,
                                                                                         thisCoil.Name,
-                                                                                        thisCoil.DXCoilType,
-                                                                                        thisCoil.DXCoilType_Num,
+                                                                                        thisCoil.coilType,
                                                                                         thisCoil.RatedTotCap,
                                                                                         thisCoil.RatedTotCap2,
                                                                                         thisCoil.RatedCOP,
@@ -10874,9 +10809,9 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_39000W_IEER_2022_ValueTest)
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023(1), 0.01);
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023_LowSpeed(1), 0.01);
 
-    EXPECT_EQ("Coil:Cooling:DX:TwoSpeed", thisCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXTwoSpeed, thisCoil.coilType);
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == thisCoil.CondenserType(1));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType(1));
     EXPECT_FALSE(DataHeatBalance::RefrigCondenserType::Evap == thisCoil.CondenserType(1));
 
     // Ckeck user curve coefficients
@@ -10925,8 +10860,7 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_39000W_IEER_2022_ValueTest)
 
     StandardRatingsResult = TwoSpeedDXCoilStandardRatings(*state,
                                                           thisCoil.Name,
-                                                          thisCoil.DXCoilType,
-                                                          thisCoil.DXCoilType_Num,
+                                                          thisCoil.coilType,
                                                           thisCoil.RatedTotCap,
                                                           thisCoil.RatedTotCap2,
                                                           thisCoil.RatedCOP,
@@ -11164,9 +11098,9 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_54000W_IEER_2022_ValueTest)
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023(1), 0.01);
     EXPECT_NEAR(934.39, thisCoil.FanPowerPerEvapAirFlowRate_2023_LowSpeed(1), 0.01);
 
-    EXPECT_EQ("Coil:Cooling:DX:TwoSpeed", thisCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXTwoSpeed, thisCoil.coilType);
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == thisCoil.CondenserType(1));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType(1));
     EXPECT_FALSE(DataHeatBalance::RefrigCondenserType::Evap == thisCoil.CondenserType(1));
 
     // Ckeck user curve coefficients
@@ -11215,8 +11149,7 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_54000W_IEER_2022_ValueTest)
 
     StandardRatingsResult = TwoSpeedDXCoilStandardRatings(*state,
                                                           thisCoil.Name,
-                                                          thisCoil.DXCoilType,
-                                                          thisCoil.DXCoilType_Num,
+                                                          thisCoil.coilType,
                                                           thisCoil.RatedTotCap,
                                                           thisCoil.RatedTotCap2,
                                                           thisCoil.RatedCOP,
@@ -11461,9 +11394,9 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_33000W_IEER_2022_ValueTest)
     EXPECT_NEAR(674.1890822, thisCoil.FanPowerPerEvapAirFlowRate_2023(1), 0.01);
     EXPECT_NEAR(280.394, thisCoil.FanPowerPerEvapAirFlowRate_2023_LowSpeed(1), 0.01);
 
-    EXPECT_EQ("Coil:Cooling:DX:TwoSpeed", thisCoil.DXCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingDXTwoSpeed, thisCoil.coilType);
 
-    EXPECT_TRUE(DataHeatBalance::RefrigCondenserType::Air == thisCoil.CondenserType(1));
+    EXPECT_ENUM_EQ(DataHeatBalance::RefrigCondenserType::Air, thisCoil.CondenserType(1));
     EXPECT_FALSE(DataHeatBalance::RefrigCondenserType::Evap == thisCoil.CondenserType(1));
 
     // Ckeck user curve coefficients
@@ -11529,7 +11462,7 @@ TEST_F(EnergyPlusFixture, TwoSpeedCoolingCoilAir_33000W_IEER_2022_ValueTest)
     TSRatedCOP.push_back(thisCoil.RatedCOP2);
 
     std::tie(IEER_2022, NetCoolingCapRated2022, EER_2022) = IEERCalculationTwoSpeed(*state,
-                                                                                    thisCoil.DXCoilType,
+                                                                                    thisCoil.coilType,
                                                                                     thisCoil.CondenserType,
                                                                                     TSCCapFTemp,
                                                                                     TSRatedTotCap,
diff --git a/tst/EnergyPlus/unit/UnitHeater.unit.cc b/tst/EnergyPlus/unit/UnitHeater.unit.cc
index 7acfeca1db1..f6f6f218675 100644
--- a/tst/EnergyPlus/unit/UnitHeater.unit.cc
+++ b/tst/EnergyPlus/unit/UnitHeater.unit.cc
@@ -1142,7 +1142,7 @@ TEST_F(EnergyPlusFixture, UnitHeater_HWHeatingCoilUAAutoSizingTest)
 
     PltSizHeatNum = PlantUtilities::MyPlantSizingIndex(*state,
                                                        "Coil:Heating:Water",
-                                                       state->dataUnitHeaters->UnitHeat(UnitHeatNum).HCoilName,
+                                                       state->dataUnitHeaters->UnitHeat(UnitHeatNum).HeatCoilName,
                                                        state->dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum,
                                                        state->dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum,
                                                        ErrorsFound);
@@ -2443,7 +2443,8 @@ TEST_F(EnergyPlusFixture, UnitHeater_SecondPriorityZoneEquipment)
         "    -1;                      !- Height Above Ground {m}",
     });
     ASSERT_TRUE(process_idf(idf_objects));
-
+    state->init_state(*state);
+    
     // OutputProcessor::TimeValue.allocate(2);
     state->dataGlobal->DDOnlySimulation = true;
 
diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc
index c47f65b2e14..c0a4f8f4a4f 100644
--- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc
+++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc
@@ -350,7 +350,8 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing)
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.branchNum = 1;
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.compNum = 1;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::CoolingWater;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
     state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize;
@@ -381,12 +382,11 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing)
     state->dataSize->PlantSizData(1).DeltaT = 5.0;
     state->dataSize->FinalSysSizing(1).MassFlowAtCoolPeak = state->dataSize->FinalSysSizing(1).DesMainVolFlow * state->dataEnvrn->StdRhoAir;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType;
+        state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
         state->dataWaterCoils->WaterCoil(CoilNum).Name;
     state->dataSize->DataWaterLoopNum = 1;
 
-    createCoilSelectionReportObj(*state);
     WaterCoils::SizeWaterCoil(*state, CoilNum);
 
     EXPECT_DOUBLE_EQ(0.159, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
@@ -419,7 +419,8 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing)
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.branchNum = 1;
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.compNum = 1;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::HeatingWater;
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
     state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize;
@@ -431,7 +432,7 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing)
     state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
         state->dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum;
     state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType;
+        state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType;
     state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
         state->dataWaterCoils->WaterCoil(CoilNum).Name;
     state->dataSize->DataWaterLoopNum = 2;
@@ -505,10 +506,10 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing)
     mySys->m_HeatingSAFMethod = DataSizing::SupplyAirFlowRate;
     mySys->m_DesignCoolingCapacity = DataSizing::AutoSize;
     mySys->m_DesignHeatingCapacity = DataSizing::AutoSize;
-    mySys->m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
-    mySys->m_CoolingCoilName = "Test Water Cooling Coil";
-    mySys->m_HeatingCoilType_Num = HVAC::Coil_HeatingWater;
-    mySys->m_HeatingCoilName = "Test Water Heating Coil";
+    mySys->m_coolCoilType = HVAC::CoilType::CoolingWater;
+    mySys->m_CoolCoilName = "Test Water Cooling Coil";
+    mySys->m_heatCoilType = HVAC::CoilType::HeatingWater;
+    mySys->m_HeatCoilName = "Test Water Heating Coil";
     state->dataWaterCoils->GetWaterCoilsInputFlag = false;             // don't overwrite these coil data
     state->dataWaterCoils->MySizeFlag = true;                          // need to size again for UnitarySystem
     state->dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate = 0.0; // reset these to be sure they get recalculated
@@ -548,8 +549,8 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing)
     mySys->m_DesignCoolingCapacity = DataSizing::AutoSize;
     mySys->m_DesignHeatingCapacity = DataSizing::AutoSize;
     // pretend this is first call and UnitarySystem doesn't know the coil index
-    mySys->m_CoolingCoilIndex = 0;
-    mySys->m_HeatingCoilIndex = 0;
+    mySys->m_CoolCoilNum = 0;
+    mySys->m_HeatCoilNum = 0;
     state->dataWaterCoils->MySizeFlag = true;
     state->dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = DataSizing::AutoSize;
     state->dataWaterCoils->WaterCoil(1).DesInletAirTemp = DataSizing::AutoSize;
@@ -1610,7 +1611,7 @@ TEST_F(ZoneUnitarySysTest, UnitarySystemModel_MultiSpeedDXCoolCoil_Only_NoFan)
     state->dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).TotalComponents = 1;
     int CompNum = 1;
-    state->dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).CompType_Num =
+    state->dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).compType =
         SimAirServingZones::CompType::UnitarySystemModel;
     state->dataAirSystemsData->PrimaryAirSystems(AirLoopNum).Branch(BranchNum).Comp(CompNum).Name = thisSys->Name;
 
@@ -5744,7 +5745,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem)
     HotWaterMassFlowRate = 1.0;
     thisSys.MaxHeatCoilFluidFlow = HotWaterMassFlowRate;
     thisSys.m_DiscreteSpeedCoolingCoil = true;
-    thisSys.m_HeatingCoilType_Num = HVAC::Coil_HeatingWater;
+    thisSys.m_heatCoilType = HVAC::CoilType::HeatingWater;
     thisSys.m_HeatingSpeedRatio = 1.0;
     thisSys.m_HeatingCycRatio = 1.0;
     thisSys.m_HeatingSpeedNum = 3;
@@ -5754,7 +5755,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem)
     state->dataWaterCoils->GetWaterCoilsInputFlag = false;
     state->dataWaterCoils->WaterCoil(1).availSched = Sched::GetScheduleAlwaysOn(*state);
     state->dataWaterCoils->WaterCoil(1).Name = "Water Heating Coil";
-    state->dataWaterCoils->WaterCoil(1).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(1).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
     state->dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = 1.0;
     state->dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = HotWaterMassFlowRate;
     state->dataWaterCoils->WaterCoil(1).UACoil = 400.0;
@@ -5808,8 +5809,8 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem)
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
         state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum;
 
-    thisSys.m_HeatingCoilIndex = 1;
-    thisSys.m_HeatingCoilName = state->dataWaterCoils->WaterCoil(1).Name;
+    thisSys.m_HeatCoilNum = 1;
+    thisSys.m_HeatCoilName = state->dataWaterCoils->WaterCoil(1).Name;
     thisSys.HeatCoilFluidInletNode = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum;
     thisSys.HeatCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
     state->dataGlobal->DoingSizing = true;
@@ -5886,7 +5887,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem)
 
     thisSys.MaxCoolCoilFluidFlow = ColdWaterMassFlowRate;
     thisSys.m_DiscreteSpeedCoolingCoil = true;
-    thisSys.m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
+    thisSys.m_coolCoilType = HVAC::CoilType::CoolingWater;
     thisSys.m_CoolingSpeedRatio = 1.0;
     thisSys.m_CoolingCycRatio = 1.0;
     thisSys.m_CoolingSpeedNum = 3;
@@ -5896,8 +5897,8 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem)
     state->dataWaterCoils->GetWaterCoilsInputFlag = false;
     state->dataWaterCoils->WaterCoil(1).availSched = Sched::GetScheduleAlwaysOn(*state);
     state->dataWaterCoils->WaterCoil(1).Name = "Water Cooling Coil";
-    state->dataWaterCoils->WaterCoil(1).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-    state->dataWaterCoils->WaterCoil(1).WaterCoilModel = WaterCoils::CoilModel::CoolingSimple;
+    state->dataWaterCoils->WaterCoil(1).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+    state->dataWaterCoils->WaterCoil(1).coilType = HVAC::CoilType::CoolingWater;
     state->dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = 1.0;
     state->dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = ColdWaterMassFlowRate;
     state->dataWaterCoils->WaterCoil(1).CoolingCoilAnalysisMode = state->dataWaterCoils->SimpleAnalysis;
@@ -5961,8 +5962,8 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem)
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
         state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum;
 
-    thisSys.m_CoolingCoilIndex = 1;
-    thisSys.m_CoolingCoilName = state->dataWaterCoils->WaterCoil(1).Name;
+    thisSys.m_CoolCoilNum = 1;
+    thisSys.m_CoolCoilName = state->dataWaterCoils->WaterCoil(1).Name;
     thisSys.CoolCoilFluidInletNode = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum;
     thisSys.CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
 
@@ -6434,14 +6435,14 @@ Curve:Biquadratic,
         state->dataLoopNodes->Node(thisSys->AirOutNode).MassFlowRate * CpAir *
         (state->dataLoopNodes->Node(thisSys->CoolCoilOutletNodeNum).Temp - state->dataLoopNodes->Node(ControlZoneNum).Temp);
     EXPECT_NEAR(ExcessSensibleCapacity, -17268.1, 0.1);
-    EXPECT_NEAR(state->dataHeatingCoils->HeatingCoil(thisSys->m_HeatingCoilIndex).HeatingCoilRate, 0.0, 0.1);
-    EXPECT_NEAR(state->dataHeatingCoils->HeatingCoil(thisSys->m_SuppHeatCoilIndex).HeatingCoilRate, 18268.1, 0.1);
+    EXPECT_NEAR(state->dataHeatingCoils->HeatingCoil(thisSys->m_HeatCoilNum).HeatingCoilRate, 0.0, 0.1);
+    EXPECT_NEAR(state->dataHeatingCoils->HeatingCoil(thisSys->m_SuppHeatCoilNum).HeatingCoilRate, 18268.1, 0.1);
     Real64 ReheatNeded = sensOut - ExcessSensibleCapacity;
     EXPECT_NEAR(ReheatNeded, 18268.1, 11.0); // same 11 watt difference as above, is this error due to tolerance?
 
     // remove heating coil to test cooling only application
     thisSys->m_HeatCoilExists = false;
-    thisSys->m_HeatingCoilIndex = 0;
+    thisSys->m_HeatCoilNum = 0;
     thisSys->HeatCoilInletNodeNum = 0;
     thisSys->HeatCoilOutletNodeNum = 0;
     thisSys->simulate(*state,
@@ -6462,7 +6463,7 @@ Curve:Biquadratic,
     // same answers as above, wihtout heating coil present, and no crash
     EXPECT_NEAR(DeliveredSensibleCapacity, SaveDeliveredSensibleCapacity, 0.0001);                                 // actual delivered capacity
     EXPECT_NEAR(DeliveredSensibleCapacity, 1010.6, 0.001);                                                         // actual delivered capacity
-    EXPECT_NEAR(state->dataHeatingCoils->HeatingCoil(thisSys->m_SuppHeatCoilIndex).HeatingCoilRate, 18268.1, 0.1); // actual reheat load to meet SP
+    EXPECT_NEAR(state->dataHeatingCoils->HeatingCoil(thisSys->m_SuppHeatCoilNum).HeatingCoilRate, 18268.1, 0.1); // actual reheat load to meet SP
     EXPECT_NEAR(thisSys->m_MoistureLoadPredicted, -1467.1, 0.1); // dehumidification control type = CoolReheat so MoistureLoad < 0
 }
 
@@ -9466,10 +9467,10 @@ Curve:Biquadratic,
 
     EXPECT_EQ(thisSys->m_DesignHeatingCapacity * 0.00005, thisSys->m_MaxHeatAirVolFlow);
     EXPECT_EQ(thisSys->m_DesignCoolingCapacity * 0.00005, thisSys->m_MaxCoolAirVolFlow);
-    EXPECT_EQ(thisSys->m_DesignCoolingCapacity, state->dataDXCoils->DXCoil(thisSys->m_CoolingCoilIndex).MSRatedTotCap(thisSys->m_NumOfSpeedCooling));
+    EXPECT_EQ(thisSys->m_DesignCoolingCapacity, state->dataDXCoils->DXCoil(thisSys->m_CoolCoilNum).MSRatedTotCap(thisSys->m_NumOfSpeedCooling));
     // 64-bit MSVS shows these next variables as identical yet other compilers show diff's, changing ASSERT_EQ to EXPECT_NEAR
     EXPECT_NEAR(thisSys->m_DesignHeatingCapacity,
-                state->dataVariableSpeedCoils->VarSpeedCoil(thisSys->m_HeatingCoilIndex).MSRatedTotCap(thisSys->m_NumOfSpeedHeating),
+                state->dataVariableSpeedCoils->VarSpeedCoil(thisSys->m_HeatCoilNum).MSRatedTotCap(thisSys->m_NumOfSpeedHeating),
                 0.001);
 
     // 3 cooling speeds with autosized MSHP design spec yielding equally distributed air flow at 1/3 per speed
@@ -10410,7 +10411,7 @@ Schedule:Compact,
     Real64 saveSystemHeatWaterFlowRate = thisSys->MaxHeatCoilFluidFlow;
     // test that heating coil was operating prior to the next call to simulate
     EXPECT_GT(state->dataLoopNodes->Node(thisSys->HeatCoilFluidInletNode).MassFlowRate, 0.0);
-    EXPECT_GT(state->dataWaterCoils->WaterCoil(thisSys->m_HeatingCoilIndex).TotWaterHeatingCoilRate, 0.0);
+    EXPECT_GT(state->dataWaterCoils->WaterCoil(thisSys->m_HeatCoilNum).TotWaterHeatingCoilRate, 0.0);
     EXPECT_LT(state->dataLoopNodes->Node(thisSys->HeatCoilInletNodeNum).Temp, state->dataLoopNodes->Node(thisSys->HeatCoilOutletNodeNum).Temp);
     thisSys->MaxHeatCoilFluidFlow = 0.0;
     // use a smaller heat load so fan heat exceeds the load and the SZVAV model will be called
@@ -10431,7 +10432,7 @@ Schedule:Compact,
     // the fact that the unit test proceeded to here means the program did not crash
     EXPECT_EQ(1.0, thisSys->m_HeatingPartLoadFrac);                                           // model tried to turn on coil
     EXPECT_EQ(0.0, state->dataLoopNodes->Node(thisSys->HeatCoilFluidInletNode).MassFlowRate); // these show coil is off
-    EXPECT_EQ(0.0, state->dataWaterCoils->WaterCoil(thisSys->m_HeatingCoilIndex).TotWaterHeatingCoilRate);
+    EXPECT_EQ(0.0, state->dataWaterCoils->WaterCoil(thisSys->m_HeatCoilNum).TotWaterHeatingCoilRate);
     EXPECT_EQ(state->dataLoopNodes->Node(thisSys->HeatCoilInletNodeNum).Temp, state->dataLoopNodes->Node(thisSys->HeatCoilOutletNodeNum).Temp);
     // reset for next unit tests
     state->dataUnitarySystems->unitarySys[0].MaxHeatCoilFluidFlow = saveSystemHeatWaterFlowRate;
@@ -10669,7 +10670,7 @@ Schedule:Compact,
     Real64 saveSystemCoolWaterFlowRate = thisSys->MaxCoolCoilFluidFlow;
     // test that cooling coil was operating prior to the next call to simulate
     EXPECT_GT(state->dataLoopNodes->Node(thisSys->CoolCoilFluidInletNode).MassFlowRate, 0.0);
-    EXPECT_GT(state->dataWaterCoils->WaterCoil(thisSys->m_CoolingCoilIndex).TotWaterCoolingCoilRate, 0.0);
+    EXPECT_GT(state->dataWaterCoils->WaterCoil(thisSys->m_CoolCoilNum).TotWaterCoolingCoilRate, 0.0);
     EXPECT_GT(state->dataLoopNodes->Node(thisSys->CoolCoilInletNodeNum).Temp, state->dataLoopNodes->Node(thisSys->CoolCoilOutletNodeNum).Temp);
     thisSys->MaxCoolCoilFluidFlow = 0.0;
     thisSys->simulate(*state,
@@ -10688,7 +10689,7 @@ Schedule:Compact,
     // the fact that the unit test proceeded to here means the program did not crash
     EXPECT_EQ(1.0, thisSys->m_CoolingPartLoadFrac);                                           // model tried to turn on coil
     EXPECT_EQ(0.0, state->dataLoopNodes->Node(thisSys->CoolCoilFluidInletNode).MassFlowRate); // these show coil is off
-    EXPECT_EQ(0.0, state->dataWaterCoils->WaterCoil(thisSys->m_CoolingCoilIndex).TotWaterCoolingCoilRate);
+    EXPECT_EQ(0.0, state->dataWaterCoils->WaterCoil(thisSys->m_CoolCoilNum).TotWaterCoolingCoilRate);
     EXPECT_EQ(state->dataLoopNodes->Node(thisSys->CoolCoilInletNodeNum).Temp, state->dataLoopNodes->Node(thisSys->CoolCoilOutletNodeNum).Temp);
     // reset for next unit tests
     thisSys->MaxCoolCoilFluidFlow = saveSystemCoolWaterFlowRate;
@@ -10780,8 +10781,7 @@ Schedule:Compact,
     EXPECT_LT(state->dataLoopNodes->Node(OutletNode).Temp, thisSys->DesignMinOutletTemp); // outlet temperature below minimum temperature limit
 
     // spot check function checkNodeSetPoint for load control
-    int constexpr coolingCoil = 0;
-    bool SetPointError = thisSys->checkNodeSetPoint(*state, AirLoopNum, thisSys->CoolCtrlNode, coolingCoil, OAUCoilOutTemp);
+    bool SetPointError = thisSys->checkNodeSetPoint(*state, AirLoopNum, thisSys->CoolCtrlNode, WhichCoil::Cool, OAUCoilOutTemp);
     EXPECT_FALSE(SetPointError);
 }
 
@@ -12104,7 +12104,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_MultiSpeedCoils_SingleMode)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "UNITARY SYSTEM MODEL";
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "AirLoopHVAC:UnitarySystem";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::UnitarySystemModel;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::UnitarySystemModel;
 
     state->dataZoneCtrls->NumTempControlledZones = 1;
     state->dataZoneCtrls->TempControlledZone.allocate(state->dataZoneCtrls->NumTempControlledZones);
@@ -14526,19 +14526,19 @@ TEST_F(ZoneUnitarySysTest, UnitarySystemModel_getUnitarySystemInputDataTest)
     EXPECT_EQ(Sched::GetScheduleAlwaysOn(*state), thisSys->m_sysAvailSched);                         // checks availability schedule name
     EXPECT_EQ("NODE 29", state->dataLoopNodes->NodeID(thisSys->AirInNode));                          // checks air inlet node name
     EXPECT_EQ("NODE 30", state->dataLoopNodes->NodeID(thisSys->AirOutNode));                         // checks air outlet node name
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)thisSys->m_FanType);                                   // checks fan object type "FAN:ONOFF"
+    EXPECT_EQ(HVAC::FanType::OnOff, thisSys->m_FanType);                                   // checks fan object type "FAN:ONOFF"
     EXPECT_EQ("SUPPLY FAN", thisSys->m_FanName);                                                     // checks fan object name
-    EXPECT_EQ((int)HVAC::FanPlace::DrawThru, (int)thisSys->m_FanPlace);                              // checks fan placement, "DrawThrough"
+    EXPECT_ENUM_EQ(HVAC::FanPlace::DrawThru, thisSys->m_FanPlace);                              // checks fan placement, "DrawThrough"
     EXPECT_EQ(nullptr, thisSys->m_fanOpModeSched);                       // checks Supply Air Fan Operating Mode Schedule Name
-    EXPECT_EQ("COIL:HEATING:WATER", thisSys->m_HeatingCoilTypeName);     // checks heating coil object type
-    EXPECT_EQ("WATER HEATING COIL", thisSys->m_HeatingCoilName);         // checks heating coil object type
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, thisSys->m_heatCoilType);     // checks heating coil object type
+    EXPECT_EQ("WATER HEATING COIL", thisSys->m_HeatCoilName);         // checks heating coil object type
     EXPECT_EQ(1, thisSys->m_HeatingSizingRatio);                         // checks dx heating coil sizing ratio
-    EXPECT_EQ(HVAC::Coil_CoolingWater, thisSys->m_CoolingCoilType_Num);  // checks cooling coil object type
-    EXPECT_EQ("WATER COOLING COIL", thisSys->m_CoolingCoilName);         // checks cooling coil name
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, thisSys->m_coolCoilType);  // checks cooling coil object type
+    EXPECT_EQ("WATER COOLING COIL", thisSys->m_CoolCoilName);         // checks cooling coil name
     EXPECT_FALSE(thisSys->m_ISHundredPercentDOASDXCoil);                 // checks DX Coil is for DOAS use
     EXPECT_EQ(7.0, thisSys->DesignMinOutletTemp);                        // checks minimum supply air temperature
     EXPECT_TRUE(thisSys->m_RunOnSensibleLoad);                           // checks for "SENSIBLEONLYLOADCONTROL"
-    EXPECT_EQ("COIL:HEATING:FUEL", thisSys->m_SuppHeatCoilTypeName);     // checks supplemental heating coil object type
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingGasOrOtherFuel, thisSys->m_SuppHeatCoilType);     // checks supplemental heating coil object type
     EXPECT_EQ("SUPPLEMENTAL HEATING COIL", thisSys->m_SuppHeatCoilName); // checks supplemental heating coil name
     EXPECT_EQ(4, thisSys->m_CoolingSAFMethod);    // checks cooling supply air flow rate sizing method, FractionOfAutosizedCoolingAirflow
     EXPECT_EQ(0.5, thisSys->m_MaxCoolAirVolFlow); // checks Cooling Fraction of Autosized Cooling Supply Air Flow Rate value
@@ -18144,8 +18144,8 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_reportUnitarySystemAncillaryPowerTe
     Real64 onElectricEnergy = thisSys.m_AncillaryOnPower * state->dataHVACGlobal->TimeStepSysSec;
     Real64 offElectricEnergy = thisSys.m_AncillaryOffPower * state->dataHVACGlobal->TimeStepSysSec;
 
-    thisSys.m_CoolingCoilType_Num = HVAC::CoilDX_CoolingTwoSpeed;
-    thisSys.m_HeatingCoilType_Num = HVAC::CoilDX_HeatingEmpirical;
+    thisSys.m_coolCoilType = HVAC::CoilType::CoolingDXTwoSpeed;
+    thisSys.m_heatCoilType = HVAC::CoilType::HeatingDXSingleSpeed;
     thisSys.m_LastMode = UnitarySystems::CoolingMode;
     state->dataUnitarySystems->CoolingLoad = true;
     thisSys.reportUnitarySystem(*state, 0);
@@ -18199,8 +18199,8 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_reportUnitarySystemAncillaryPowerTe
     EXPECT_NEAR(thisSys.m_ElecPowerConsumption, ancillaryAvgEnergy, 0.000001);
 
     // test with discrete speed water coils
-    thisSys.m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
-    thisSys.m_HeatingCoilType_Num = HVAC::Coil_HeatingWater;
+    thisSys.m_coolCoilType = HVAC::CoilType::CoolingWater;
+    thisSys.m_heatCoilType = HVAC::CoilType::HeatingWater;
     // coil cycles on and off just like DX coils
     thisSys.m_DiscreteSpeedCoolingCoil = true;
     // switch on-off power values, should have opposite results but uses same code
@@ -18810,13 +18810,12 @@ Curve:Quadratic,
     EXPECT_GT(state->dataLoopNodes->Node(2).Temp, state->dataLoopNodes->Node(3).Temp);
 
     // spot check function checkNodeSetPoint for set point control
-    int constexpr heatingCoil = 1;
-    bool SetPointError = thisSys->checkNodeSetPoint(*state, AirLoopNum, thisSys->HeatCtrlNode, heatingCoil, OAUCoilOutTemp);
+    bool SetPointError = thisSys->checkNodeSetPoint(*state, AirLoopNum, thisSys->HeatCtrlNode, WhichCoil::Heat, OAUCoilOutTemp);
     EXPECT_FALSE(SetPointError);
 
     // test as if control node were 0
     thisSys->HeatCtrlNode = 0;
-    SetPointError = thisSys->checkNodeSetPoint(*state, AirLoopNum, thisSys->HeatCtrlNode, heatingCoil, OAUCoilOutTemp);
+    SetPointError = thisSys->checkNodeSetPoint(*state, AirLoopNum, thisSys->HeatCtrlNode, WhichCoil::Heat, OAUCoilOutTemp);
     EXPECT_TRUE(SetPointError);
 }
 
@@ -19355,7 +19354,7 @@ TEST_F(EnergyPlusFixture, WaterCoil_getCoilWaterSystemInputDataTest)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "COIL SYSTEM WATER";
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "COILSYSTEM:COOLING:WATER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::CoilSystemWater;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::CoilSystemWater;
 
     int unitarySysIndex(0);
     bool ErrorsFound(false);
@@ -19374,8 +19373,8 @@ TEST_F(EnergyPlusFixture, WaterCoil_getCoilWaterSystemInputDataTest)
     EXPECT_EQ(thisSys.m_minAirToWaterTempOffset, 2.0);
     EXPECT_ENUM_EQ(thisSys.m_DehumidControlType_Num, UnitarySys::DehumCtrlType::None);
     EXPECT_ENUM_EQ(thisSys.m_ControlType, UnitarySys::UnitarySysCtrlType::Setpoint);
-    EXPECT_EQ(thisSys.m_CoolingCoilType_Num, HVAC::Coil_CoolingWater);
-    EXPECT_EQ(thisSys.m_CoolingCoilName, "WATER COOLING COIL");
+    EXPECT_ENUM_EQ(thisSys.m_coolCoilType, HVAC::CoilType::CoolingWater);
+    EXPECT_EQ(thisSys.m_CoolCoilName, "WATER COOLING COIL");
     EXPECT_TRUE(thisSys.m_CoolCoilExists);
     EXPECT_TRUE(thisSys.m_TemperatureOffsetControlActive);
     EXPECT_TRUE(thisSys.m_RunOnSensibleLoad);
@@ -19443,7 +19442,7 @@ TEST_F(EnergyPlusFixture, DetailedWaterCoil_getCoilWaterSystemInputDataTest)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "COIL SYSTEM WATER";
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "COILSYSTEM:COOLING:WATER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::CoilSystemWater;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::CoilSystemWater;
 
     int unitarySysIndex(0);
     bool ErrorsFound(false);
@@ -19461,8 +19460,8 @@ TEST_F(EnergyPlusFixture, DetailedWaterCoil_getCoilWaterSystemInputDataTest)
     EXPECT_EQ(thisSys.m_minAirToWaterTempOffset, 2.0);
     EXPECT_ENUM_EQ(thisSys.m_DehumidControlType_Num, UnitarySys::DehumCtrlType::CoolReheat);
     EXPECT_ENUM_EQ(thisSys.m_ControlType, UnitarySys::UnitarySysCtrlType::Setpoint);
-    EXPECT_EQ(thisSys.m_CoolingCoilType_Num, HVAC::Coil_CoolingWaterDetailed);
-    EXPECT_EQ(thisSys.m_CoolingCoilName, "WATER COOLING COIL");
+    EXPECT_ENUM_EQ(thisSys.m_coolCoilType, HVAC::CoilType::CoolingWaterDetailed);
+    EXPECT_EQ(thisSys.m_CoolCoilName, "WATER COOLING COIL");
     EXPECT_TRUE(thisSys.m_CoolCoilExists);
     EXPECT_TRUE(thisSys.m_TemperatureOffsetControlActive);
     EXPECT_TRUE(thisSys.m_RunOnSensibleLoad);
@@ -19546,7 +19545,7 @@ TEST_F(EnergyPlusFixture, HXAssistedWaterCoil_getCoilWaterSystemInputDataTest)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "COIL SYSTEM WATER";
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "COILSYSTEM:COOLING:WATER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::CoilSystemWater;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::CoilSystemWater;
 
     int unitarySysIndex(0);
     bool ErrorsFound(false);
@@ -19564,8 +19563,8 @@ TEST_F(EnergyPlusFixture, HXAssistedWaterCoil_getCoilWaterSystemInputDataTest)
     EXPECT_EQ(thisSys.m_minAirToWaterTempOffset, 2.0);
     EXPECT_ENUM_EQ(thisSys.m_DehumidControlType_Num, UnitarySys::DehumCtrlType::CoolReheat);
     EXPECT_ENUM_EQ(thisSys.m_ControlType, UnitarySys::UnitarySysCtrlType::Setpoint);
-    EXPECT_EQ(thisSys.m_CoolingCoilType_Num, HVAC::Coil_CoolingWater);
-    EXPECT_EQ(thisSys.m_CoolingCoilName, "WATER COOLING COIL");
+    EXPECT_ENUM_EQ(thisSys.m_coolCoilType, HVAC::CoilType::CoolingWater);
+    EXPECT_EQ(thisSys.m_CoolCoilName, "WATER COOLING COIL");
     EXPECT_TRUE(thisSys.m_CoolCoilExists);
     EXPECT_TRUE(thisSys.m_TemperatureOffsetControlActive);
     EXPECT_TRUE(thisSys.m_RunOnSensibleLoad);
@@ -19624,7 +19623,7 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_ControlStatusTest)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "COIL SYSTEM WATER";
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "COILSYSTEM:COOLING:WATER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::CoilSystemWater;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::CoilSystemWater;
     state->dataAirLoop->AirLoopControlInfo.allocate(1);
     state->dataAirLoop->AirLoopControlInfo(1).UnitarySys = true;
 
@@ -19666,7 +19665,7 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_ControlStatusTest)
 
     thisSys.MaxCoolCoilFluidFlow = ColdWaterMassFlowRate;
     thisSys.MaxCoolAirMassFlow = AirMassFlowRate;
-    thisSys.m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
+    thisSys.m_coolCoilType = HVAC::CoilType::CoolingWater;
     thisSys.m_CoolingSpeedRatio = 1.0;
     thisSys.m_CoolingCycRatio = 1.0;
     thisSys.m_CoolingSpeedNum = 1;
@@ -19674,8 +19673,8 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_ControlStatusTest)
     state->dataWaterCoils->CheckEquipName.allocate(1);
     state->dataWaterCoils->GetWaterCoilsInputFlag = false;
     state->dataWaterCoils->WaterCoil(1).availSched = Sched::GetScheduleAlwaysOn(*state);
-    state->dataWaterCoils->WaterCoil(1).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-    state->dataWaterCoils->WaterCoil(1).WaterCoilModel = WaterCoils::CoilModel::CoolingSimple;
+    state->dataWaterCoils->WaterCoil(1).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+    state->dataWaterCoils->WaterCoil(1).coilType = HVAC::CoilType::CoolingWater;
     state->dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = 1.0;
     state->dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = ColdWaterMassFlowRate;
     state->dataWaterCoils->WaterCoil(1).CoolingCoilAnalysisMode = state->dataWaterCoils->SimpleAnalysis;
@@ -19757,8 +19756,8 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_ControlStatusTest)
     EXPECT_EQ(thisSys.m_minAirToWaterTempOffset, 2.0);
     EXPECT_ENUM_EQ(thisSys.m_DehumidControlType_Num, UnitarySys::DehumCtrlType::None);
     EXPECT_ENUM_EQ(thisSys.m_ControlType, UnitarySys::UnitarySysCtrlType::Setpoint);
-    EXPECT_EQ(thisSys.m_CoolingCoilType_Num, HVAC::Coil_CoolingWater);
-    EXPECT_EQ(thisSys.m_CoolingCoilName, "WATER COOLING COIL");
+    EXPECT_ENUM_EQ(thisSys.m_coolCoilType, HVAC::CoilType::CoolingWater);
+    EXPECT_EQ(thisSys.m_CoolCoilName, "WATER COOLING COIL");
     EXPECT_TRUE(thisSys.m_CoolCoilExists);
     EXPECT_TRUE(thisSys.m_TemperatureOffsetControlActive);
     EXPECT_TRUE(thisSys.m_RunOnSensibleLoad);
@@ -19870,7 +19869,7 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_CalcTest)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "COIL SYSTEM WATER";
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "COILSYSTEM:COOLING:WATER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::CoilSystemWater;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::CoilSystemWater;
     state->dataAirLoop->AirLoopControlInfo.allocate(1);
     state->dataAirLoop->AirLoopControlInfo(1).UnitarySys = true;
 
@@ -19917,7 +19916,7 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_CalcTest)
 
     thisSys.MaxCoolCoilFluidFlow = ColdWaterMassFlowRate;
     thisSys.MaxCoolAirMassFlow = AirMassFlowRate;
-    thisSys.m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
+    thisSys.m_coolCoilType = HVAC::CoilType::CoolingWater;
     thisSys.m_CoolingSpeedRatio = 1.0;
     thisSys.m_CoolingCycRatio = 1.0;
     thisSys.m_CoolingSpeedNum = 1;
@@ -19925,8 +19924,8 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_CalcTest)
     state->dataWaterCoils->CheckEquipName.allocate(1);
     state->dataWaterCoils->GetWaterCoilsInputFlag = false;
     state->dataWaterCoils->WaterCoil(1).availSched = Sched::GetScheduleAlwaysOn(*state);
-    state->dataWaterCoils->WaterCoil(1).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-    state->dataWaterCoils->WaterCoil(1).WaterCoilModel = WaterCoils::CoilModel::CoolingSimple;
+    state->dataWaterCoils->WaterCoil(1).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+    state->dataWaterCoils->WaterCoil(1).coilType = HVAC::CoilType::CoolingWater;
     state->dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = 1.0;
     state->dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = ColdWaterMassFlowRate;
     state->dataWaterCoils->WaterCoil(1).CoolingCoilAnalysisMode = state->dataWaterCoils->SimpleAnalysis;
@@ -20007,8 +20006,8 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_CalcTest)
     EXPECT_EQ(thisSys.m_minAirToWaterTempOffset, 2.0);
     EXPECT_ENUM_EQ(thisSys.m_DehumidControlType_Num, UnitarySys::DehumCtrlType::None);
     EXPECT_ENUM_EQ(thisSys.m_ControlType, UnitarySys::UnitarySysCtrlType::Setpoint);
-    EXPECT_EQ(thisSys.m_CoolingCoilType_Num, HVAC::Coil_CoolingWater);
-    EXPECT_EQ(thisSys.m_CoolingCoilName, "WATER COOLING COIL");
+    EXPECT_ENUM_EQ(thisSys.m_coolCoilType, HVAC::CoilType::CoolingWater);
+    EXPECT_EQ(thisSys.m_CoolCoilName, "WATER COOLING COIL");
     EXPECT_TRUE(thisSys.m_CoolCoilExists);
     EXPECT_TRUE(thisSys.m_TemperatureOffsetControlActive);
     EXPECT_TRUE(thisSys.m_RunOnSensibleLoad);
@@ -20136,7 +20135,7 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_HeatRecoveryLoop)
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1);
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).Name = "COIL SYSTEM WATER";
     state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "COILSYSTEM:COOLING:WATER";
-    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::CompType::CoilSystemWater;
+    state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).compType = SimAirServingZones::CompType::CoilSystemWater;
     state->dataAirLoop->AirLoopControlInfo.allocate(1);
     state->dataAirLoop->AirLoopControlInfo(1).UnitarySys = true;
 
@@ -20183,7 +20182,7 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_HeatRecoveryLoop)
 
     thisSys.MaxCoolCoilFluidFlow = ColdWaterMassFlowRate;
     thisSys.MaxCoolAirMassFlow = AirMassFlowRate;
-    thisSys.m_CoolingCoilType_Num = HVAC::Coil_CoolingWater;
+    thisSys.m_coolCoilType = HVAC::CoilType::CoolingWater;
     thisSys.m_CoolingSpeedRatio = 1.0;
     thisSys.m_CoolingCycRatio = 1.0;
     thisSys.m_CoolingSpeedNum = 1;
@@ -20192,8 +20191,8 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_HeatRecoveryLoop)
     state->dataWaterCoils->GetWaterCoilsInputFlag = false;
     for (int i = 1; i <= 2; ++i) {
         state->dataWaterCoils->WaterCoil(i).availSched = Sched::GetScheduleAlwaysOn(*state);
-        state->dataWaterCoils->WaterCoil(i).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-        state->dataWaterCoils->WaterCoil(i).WaterCoilModel = WaterCoils::CoilModel::CoolingSimple;
+        state->dataWaterCoils->WaterCoil(i).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+        state->dataWaterCoils->WaterCoil(i).coilType = HVAC::CoilType::CoolingWater;
         state->dataWaterCoils->WaterCoil(i).DesAirVolFlowRate = 1.0;
         state->dataWaterCoils->WaterCoil(i).MaxWaterVolFlowRate = ColdWaterMassFlowRate;
         state->dataWaterCoils->WaterCoil(i).CoolingCoilAnalysisMode = state->dataWaterCoils->SimpleAnalysis;
@@ -20286,8 +20285,8 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_HeatRecoveryLoop)
     EXPECT_EQ(thisSys.m_minAirToWaterTempOffset, 2.0);
     EXPECT_ENUM_EQ(thisSys.m_DehumidControlType_Num, UnitarySys::DehumCtrlType::None);
     EXPECT_ENUM_EQ(thisSys.m_ControlType, UnitarySys::UnitarySysCtrlType::Setpoint);
-    EXPECT_EQ(thisSys.m_CoolingCoilType_Num, HVAC::Coil_CoolingWater);
-    EXPECT_EQ(thisSys.m_CoolingCoilName, "WATER COOLING COIL");
+    EXPECT_ENUM_EQ(thisSys.m_coolCoilType, HVAC::CoilType::CoolingWater);
+    EXPECT_EQ(thisSys.m_CoolCoilName, "WATER COOLING COIL");
     EXPECT_TRUE(thisSys.m_CoolCoilExists);
     EXPECT_TRUE(thisSys.m_TemperatureOffsetControlActive);
     EXPECT_TRUE(thisSys.m_RunOnSensibleLoad);
@@ -20409,10 +20408,9 @@ TEST_F(AirloopUnitarySysTest, WSHPVariableSpeedCoilSizing)
     int CoilNum1 = 1;
     state->dataVariableSpeedCoils->GetCoilsInputFlag = false;
     state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).Name = "WSHPVSCooling";
-    state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).VSCoilType = HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
+    state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).coilType = HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit;
     state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).NumOfSpeeds = 10;
     state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).NormSpedLevel = 10;
-    state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).VarSpeedCoilType = "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit";
     state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).CondenserType = DataHeatBalance::RefrigCondenserType::Water;
     state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).CoolHeatType = "Cooling";
     state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).MSRatedWaterVolFlowPerRatedTotCap(10) = 0.00000001;
@@ -20473,9 +20471,9 @@ TEST_F(AirloopUnitarySysTest, WSHPVariableSpeedCoilSizing)
     thisSys.m_sysType = UnitarySys::SysType::Unitary;
     thisSys.Name = compName;
     thisSys.m_CoolCoilExists = true;
-    thisSys.m_CoolingCoilName = state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).Name;
-    thisSys.m_CoolingCoilType_Num = HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
-    thisSys.m_CoolingCoilIndex = CoilNum1;
+    thisSys.m_CoolCoilName = state->dataVariableSpeedCoils->VarSpeedCoil(CoilNum1).Name;
+    thisSys.m_coolCoilType = HVAC::CoilType::CoolingWAHPVariableSpeedEquationFit;
+    thisSys.m_CoolCoilNum = CoilNum1;
     thisSys.m_CoolingSAFMethod = DataSizing::SupplyAirFlowRate;
     thisSys.m_MaxCoolAirVolFlow = DataSizing::AutoSize;
     thisSys.m_DesignCoolingCapacity = DataSizing::AutoSize;
diff --git a/tst/EnergyPlus/unit/VariableSpeedCoils.unit.cc b/tst/EnergyPlus/unit/VariableSpeedCoils.unit.cc
index 42406e55aa5..39ec1b428bf 100644
--- a/tst/EnergyPlus/unit/VariableSpeedCoils.unit.cc
+++ b/tst/EnergyPlus/unit/VariableSpeedCoils.unit.cc
@@ -3171,7 +3171,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_ASHP_Cooling)
     state->init_state(*state);
 
     VariableSpeedCoils::GetVarSpeedCoilInput(*state);
-    EXPECT_EQ(VariableSpeedCoils::GetVSCoilRatedSourceTemp(*state, 1.0), 35.0);
+    EXPECT_EQ(VariableSpeedCoils::GetCoilRatedSourceTemp(*state, 1.0), 35.0);
 }
 
 TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_ASHP_Heating)
@@ -3303,7 +3303,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_ASHP_Heating)
     state->init_state(*state);
 
     VariableSpeedCoils::GetVarSpeedCoilInput(*state);
-    EXPECT_EQ(VariableSpeedCoils::GetVSCoilRatedSourceTemp(*state, 1.0), 8.3333);
+    EXPECT_EQ(VariableSpeedCoils::GetCoilRatedSourceTemp(*state, 1), 8.3333);
 }
 
 TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_AWHP)
@@ -3507,7 +3507,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_AWHP)
     state->init_state(*state);
 
     VariableSpeedCoils::GetVarSpeedCoilInput(*state);
-    EXPECT_EQ(VariableSpeedCoils::GetVSCoilRatedSourceTemp(*state, 1.0), 55.72);
+    EXPECT_EQ(VariableSpeedCoils::GetCoilRatedSourceTemp(*state, 1), 55.72);
 }
 
 TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_WSHP_Cooling)
@@ -3738,7 +3738,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_WSHP_Cooling)
     state->init_state(*state);
 
     VariableSpeedCoils::GetVarSpeedCoilInput(*state);
-    EXPECT_EQ(VariableSpeedCoils::GetVSCoilRatedSourceTemp(*state, 1.0), 29.4444);
+    EXPECT_EQ(VariableSpeedCoils::GetCoilRatedSourceTemp(*state, 1), 29.4444);
 }
 
 TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_WSHP_Heating)
@@ -3953,7 +3953,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_RatedSource_Temp_WSHP_Heating)
     state->init_state(*state);
 
     VariableSpeedCoils::GetVarSpeedCoilInput(*state);
-    EXPECT_EQ(VariableSpeedCoils::GetVSCoilRatedSourceTemp(*state, 1.0), 21.1111);
+    EXPECT_EQ(VariableSpeedCoils::GetCoilRatedSourceTemp(*state, 1), 21.1111);
 }
 
 TEST_F(EnergyPlusFixture, VariableSpeedCooling_Initialization)
@@ -7359,7 +7359,7 @@ TEST_F(EnergyPlusFixture, VariableSpeedCoils_UpdateVarSpeedCoil_Test)
     thisInletNode.GenContam = 12.345;
     thisOutletNode.GenContam = 0.0;
     thisVarSpeedCoil.reportCoilFinalSizes = false;
-    thisVarSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed;
+    thisVarSpeedCoil.coilType == HVAC::CoilType::CoolingDXVariableSpeed;
 
     // Run the test
     VariableSpeedCoils::UpdateVarSpeedCoil(*state, coilNum);
diff --git a/tst/EnergyPlus/unit/WaterCoils.unit.cc b/tst/EnergyPlus/unit/WaterCoils.unit.cc
index d8acb4800a1..7c87949e193 100644
--- a/tst/EnergyPlus/unit/WaterCoils.unit.cc
+++ b/tst/EnergyPlus/unit/WaterCoils.unit.cc
@@ -204,7 +204,7 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Cooling Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
     state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize;
@@ -228,7 +228,6 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing)
     state->dataSize->FinalSysSizing(1).MassFlowAtCoolPeak = state->dataSize->FinalSysSizing(1).DesMainVolFlow * state->dataEnvrn->StdRhoAir;
     state->dataSize->DataWaterLoopNum = 1;
 
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
 
     EXPECT_DOUBLE_EQ(0.00159, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
@@ -286,7 +285,7 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing)
     state->dataAirLoop->AirLoopControlInfo(1).UnitarySys = true;
 
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Heating Coil";
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
     state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize;
@@ -317,7 +316,7 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing)
     state->dataSize->FinalSysSizing(1).MassFlowAtCoolPeak = state->dataSize->FinalSysSizing(1).DesMainVolFlow * state->dataEnvrn->StdRhoAir;
 
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Heating Coil 2";
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
     state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize;
@@ -437,8 +436,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::HeatingSimple;
+
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::HeatingWater;
     state->dataWaterCoils->WaterCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOn(*state);
 
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
@@ -469,7 +469,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing)
     state->dataWaterCoils->MySizeFlag(1) = true;
 
     // run water coil sizing
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
     EXPECT_DOUBLE_EQ(1.0, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
 
@@ -590,8 +589,8 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::HeatingSimple;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::HeatingWater;
     state->dataWaterCoils->WaterCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOn(*state);
 
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
@@ -622,7 +621,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing)
     state->dataWaterCoils->MySizeFlag(1) = true;
 
     // run water coil sizing
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
     EXPECT_DOUBLE_EQ(1.0, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
 
@@ -746,8 +744,8 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::HeatingSimple;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::HeatingWater;
     state->dataWaterCoils->WaterCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOn(*state);
 
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
@@ -779,7 +777,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp)
     state->dataWaterCoils->MySizeFlag(1) = true;
 
     // run water coil sizing
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
     EXPECT_DOUBLE_EQ(1.0, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
 
@@ -860,8 +857,8 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Simple Water Cooling Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::CoolingSimple;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::CoolingWater;
 
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
     state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize;
@@ -890,7 +887,6 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing)
     state->dataSize->DataWaterLoopNum = 1;
 
     // run water coil sizing
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
     EXPECT_DOUBLE_EQ(1.0, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
 
@@ -960,8 +956,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Detailed Water Cooling Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::CoolingDetailed;
+
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterCooling;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::CoolingWaterDetailed;
 
     state->dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea = 6.23816;
     state->dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea = 6.20007018;
@@ -1005,7 +1002,6 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing)
     state->dataSize->DataWaterLoopNum = 1;
 
     // run water coil sizing
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
     EXPECT_DOUBLE_EQ(1.0, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
 
@@ -1070,8 +1066,8 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Detailed Water Cooling Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOff(*state);
 
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::CoolingDetailed;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::CoolingWaterDetailed;
 
     state->dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea = 6.23816;
     state->dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea = 6.20007018;
@@ -1130,7 +1126,6 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailed_WarningMath)
     OutputReportPredefined::SetPredefinedTables(*state);
 
     // run water coil sizing
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
     EXPECT_DOUBLE_EQ(1.0, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
 
@@ -1254,8 +1249,9 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing)
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
 
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::HeatingSimple;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::HeatingWater;
+
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
     state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize;
     state->dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize;
@@ -1283,7 +1279,6 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing)
     state->dataSize->DataWaterLoopNum = 1;
 
     // run water coil sizing
-    createCoilSelectionReportObj(*state);
     SizeWaterCoil(*state, CoilNum);
     EXPECT_DOUBLE_EQ(1.0, state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate);
 
@@ -1349,8 +1344,9 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest)
     state->dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil";
     state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1;
     PlantUtilities::SetPlantLocationLinks(*state, state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc);
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilModel::HeatingSimple;
-    state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
+
+    state->dataWaterCoils->WaterCoil(CoilNum).coilType = HVAC::CoilType::HeatingWater;
+    state->dataWaterCoils->WaterCoil(CoilNum).coilPlantType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating;
     state->dataWaterCoils->WaterCoil(CoilNum).availSched = Sched::GetScheduleAlwaysOn(*state);
 
     state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true;
@@ -1570,14 +1566,14 @@ TEST_F(WaterCoilsTest, FanCoilCoolingWaterFlowTest)
 
     GetZoneEquipmentData(*state);
     GetFanInput(*state);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFans->fans(1)->type);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFans->fans(1)->type);
 
     GetFanCoilUnits(*state);
     EXPECT_ENUM_EQ(CCM::ConsFanVarFlow, state->dataFanCoilUnits->FanCoil(1).CapCtrlMeth_Num);
     EXPECT_EQ("OUTDOORAIR:MIXER", state->dataFanCoilUnits->FanCoil(1).OAMixType);
-    EXPECT_EQ((int)HVAC::FanType::OnOff, (int)state->dataFanCoilUnits->FanCoil(1).fanType);
-    EXPECT_EQ("COIL:COOLING:WATER", state->dataFanCoilUnits->FanCoil(1).CCoilType);
-    EXPECT_EQ("COIL:HEATING:WATER", state->dataFanCoilUnits->FanCoil(1).HCoilType);
+    EXPECT_ENUM_EQ(HVAC::FanType::OnOff, state->dataFanCoilUnits->FanCoil(1).fanType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::CoolingWater, state->dataFanCoilUnits->FanCoil(1).coolCoilType);
+    EXPECT_ENUM_EQ(HVAC::CoilType::HeatingWater, state->dataFanCoilUnits->FanCoil(1).heatCoilType);
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -1713,8 +1709,8 @@ TEST_F(WaterCoilsTest, FanCoilCoolingWaterFlowTest)
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopNum = 1;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand;
-    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
-    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(2).WaterOutletNodeNum;
+    state->dataFanCoilUnits->FanCoil(1).HeatCoilFluidOutletNode = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum;
+    state->dataFanCoilUnits->FanCoil(1).CoolCoilFluidOutletNode = state->dataWaterCoils->WaterCoil(2).WaterOutletNodeNum;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.branchNum = 1;
     state->dataFanCoilUnits->FanCoil(1).CoolCoilPlantLoc.compNum = 1;
     state->dataFanCoilUnits->FanCoil(1).HeatCoilPlantLoc.branchNum = 1;
diff --git a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc
index 8f41e31ae80..58c14ba0a42 100644
--- a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc
+++ b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc
@@ -3517,7 +3517,7 @@ TEST_F(EnergyPlusFixture, Desuperheater_WAHP_VSEQ_Coil_Test)
     state->dataLoopNodes->Node(5).MassFlowRate = state->dataVariableSpeedCoils->VarSpeedCoil(1).MSRatedAirMassFlowRate(2);
     state->dataVariableSpeedCoils->VarSpeedCoil(1).MSRatedCBF(1) =
         DXCoils::CalcCBF(*state,
-                         state->dataVariableSpeedCoils->VarSpeedCoil(1).VarSpeedCoilType,
+                         state->dataVariableSpeedCoils->VarSpeedCoil(1).coilType,
                          state->dataVariableSpeedCoils->VarSpeedCoil(1).Name,
                          26.6667,
                          0.0111847,
@@ -3527,7 +3527,7 @@ TEST_F(EnergyPlusFixture, Desuperheater_WAHP_VSEQ_Coil_Test)
                          true);
     state->dataVariableSpeedCoils->VarSpeedCoil(1).MSRatedCBF(2) =
         DXCoils::CalcCBF(*state,
-                         state->dataVariableSpeedCoils->VarSpeedCoil(1).VarSpeedCoilType,
+                         state->dataVariableSpeedCoils->VarSpeedCoil(1).coilType,
                          state->dataVariableSpeedCoils->VarSpeedCoil(1).Name,
                          26.6667,
                          0.0111847,
diff --git a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc
index 4bce5dcf804..6f865e461ae 100644
--- a/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc
+++ b/tst/EnergyPlus/unit/WaterToAirHeatPump.unit.cc
@@ -236,7 +236,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir)
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
         state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).Name;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).WAHPType;
+        state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).coilPlantType;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
         state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).WaterInletNodeNum;
 
@@ -271,7 +271,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpTest_SimWaterToAir)
     state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
         state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).Name;
     state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).WAHPType;
+        state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).coilPlantType;
     state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
         state->dataWaterToAirHeatPump->WatertoAirHP(HPNum).WaterInletNodeNum;
 
diff --git a/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc b/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc
index e04250136f1..fe8ec0a944e 100644
--- a/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc
+++ b/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc
@@ -63,6 +63,7 @@
 #include <EnergyPlus/InputProcessing/InputProcessor.hh>
 #include <EnergyPlus/Plant/DataPlant.hh>
 #include <EnergyPlus/Psychrometrics.hh>
+#include <EnergyPlus/ReportCoilSelection.hh>
 #include <EnergyPlus/WaterToAirHeatPumpSimple.hh>
 
 using namespace EnergyPlus;
@@ -95,13 +96,17 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAir)
     state->dataSize->DesDayWeath.allocate(1);
     state->dataSize->DesDayWeath(1).Temp.allocate(24);
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WAHPType = WatertoAirHP::Cooling;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedAirVolFlowRate = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCapCoolTotal = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCapCoolSens = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedWaterVolFlowRate = 0.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterOutletNodeNum = 2;
+    auto &wahp = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum);
+    wahp.Name = "WAHP Cooling Coil";
+    wahp.coilType = HVAC::CoilType::CoolingWAHPSimple;
+    wahp.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
+    wahp.coilReportNum = ReportCoilSelection::getReportIndex(*state, wahp.Name, wahp.coilType); 
+    wahp.RatedAirVolFlowRate = AutoSize;
+    wahp.RatedCapCoolTotal = AutoSize;
+    wahp.RatedCapCoolSens = AutoSize;
+    wahp.RatedWaterVolFlowRate = 0.0;
+    wahp.WaterInletNodeNum = 1;
+    wahp.WaterOutletNodeNum = 2;
 
     state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).DesCoolVolFlow = 0.20;
     state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).DesHeatVolFlow = 0.20;
@@ -167,11 +172,11 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAir)
     curve3->inputLimits[3].max = 38;
 
     // performance curve coefficients
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).TotalCoolCapCurve = curve1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).SensCoolCapCurve = curve2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).CoolPowCurve = curve3;
+    wahp.TotalCoolCapCurve = curve1;
+    wahp.SensCoolCapCurve = curve2;
+    wahp.CoolPowCurve = curve3;
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCOPCoolAtRatedCdts = 5.12;
+    wahp.RatedCOPCoolAtRatedCdts = 5.12;
 
     state->dataSize->DesDayWeath(1).Temp(15) = 32.0;
     state->dataEnvrn->StdBaroPress = 101325.0;
@@ -190,12 +195,12 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAir)
     loopsidebranch.TotalComponents = 1;
     loopsidebranch.Comp.allocate(1);
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).Name;
+        wahp.Name;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WAHPPlantType;
+        wahp.coilPlantType;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).plantLoc.loopNum = 1;
+        wahp.WaterInletNodeNum;
+    wahp.plantLoc.loopNum = 1;
 
     // plant loop design leaving water temperature (design entering water temperature for WAHP coil)
     state->dataSize->PlantSizData.allocate(1);
@@ -207,14 +212,14 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAir)
     EXPECT_DOUBLE_EQ(0.0075, state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).CoolDesHumRat);
 
     // check that the total cooling capacity is >= the sensible cooling capacity
-    EXPECT_GE(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCapCoolTotal,
-              state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCapCoolSens);
+    EXPECT_GE(wahp.RatedCapCoolTotal,
+              wahp.RatedCapCoolSens);
 
-    if (state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCapCoolTotal != 0.0) {
+    if (wahp.RatedCapCoolTotal != 0.0) {
         ShowMessage(*state,
                     format("SizeHVACWaterToAir: Rated Sensible Heat Ratio = {:.2R} [-]",
-                           state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCapCoolSens /
-                               state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).RatedCapCoolTotal));
+                           wahp.RatedCapCoolSens /
+                               wahp.RatedCapCoolTotal));
     }
 }
 
@@ -367,20 +372,20 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimple_TestAirFlow)
     Real64 ActualAirflow(1.0);
     Real64 DesignWaterflow(15.0);
     Real64 CpAir = PsyCpAirFnW(0.007);
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Temp = 5.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Enthalpy = 44650.0;
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate = DesignWaterflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate = DesignWaterflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMax = DesignWaterflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMaxAvail =
-        DesignWaterflow;
+    auto &wahp = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum);
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).Temp = 5.0;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).Enthalpy = 44650.0;
 
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        ActualAirflow; // rated condition
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Temp = 26.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).HumRat = 0.007;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Enthalpy = 43970.75;
+    wahp.DesignWaterMassFlowRate = DesignWaterflow;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRate = DesignWaterflow;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRateMax = DesignWaterflow;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRateMaxAvail = DesignWaterflow;
+
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate = ActualAirflow; // rated condition
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).Temp = 26.0;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).HumRat = 0.007;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).Enthalpy = 43970.75;
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -398,11 +403,11 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimple_TestAirFlow)
     state->dataPlnt->PlantLoop(1).FluidName = "WATER";
     state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state);
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).Name;
+        wahp.Name;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WAHPPlantType;
+        wahp.coilPlantType;
     state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum;
+        wahp.WaterInletNodeNum;
 
     HVAC::CompressorOp compressorOp = HVAC::CompressorOp::On;
     HVAC::FanOp fanOp = HVAC::FanOp::Cycling;
@@ -411,95 +416,92 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimple_TestAirFlow)
     Real64 LatentLoad(0.0);
     Real64 PartLoadRatio(1.0);
     Real64 OnOffAirFlowRatio(1.0);
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).plantLoc.loopNum = 1;
+    wahp.plantLoc.loopNum = 1;
 
     state->dataEnvrn->OutBaroPress = 101325.0;
 
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 1.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.85781, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 16000 * 0.89755, 0.1);
+    EXPECT_EQ(wahp.AirMassFlowRate, 1.0);
+    EXPECT_NEAR(wahp.QLoadTotal, 20000 * 0.85781, 0.1);
+    EXPECT_NEAR(wahp.QSensible, 16000 * 0.89755, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 2853.98 * 0.85781, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 26.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, 43970.75);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy, 43970.75 - (17156.275 / 1.0), 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
+    EXPECT_NEAR(wahp.OutletAirEnthalpy, 43970.75 - (17156.275 / 1.0), 0.1);
+    EXPECT_NEAR(wahp.OutletAirDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate =
         ActualAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 0.5);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.85781 * 0.5, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 16000 * 0.89755 * 0.5, 0.1);
+    EXPECT_EQ(wahp.AirMassFlowRate, 0.5);
+    EXPECT_NEAR(wahp.QLoadTotal, 20000 * 0.85781 * 0.5, 0.1);
+    EXPECT_NEAR(wahp.QSensible, 16000 * 0.89755 * 0.5, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 2853.98 * 0.85781 * 0.5, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 26.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, 43970.75);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy, 43970.75 - (17156.275 / 1.0), 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
+    EXPECT_NEAR(wahp.OutletAirEnthalpy, 43970.75 - (17156.275 / 1.0), 0.1);
+    EXPECT_NEAR(wahp.OutletAirDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
 
     // constant fan
     fanOp = HVAC::FanOp::Continuous;
     PartLoadRatio = 1.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate =
         ActualAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 1.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.85781, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 16000 * 0.89755, 0.1);
+    EXPECT_EQ(wahp.AirMassFlowRate, 1.0);
+    EXPECT_NEAR(wahp.QLoadTotal, 20000 * 0.85781, 0.1);
+    EXPECT_NEAR(wahp.QSensible, 16000 * 0.89755, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 2853.98 * 0.85781, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 26.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, 43970.75);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy, 43970.75 - (17156.275 / 1.0), 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
+    EXPECT_NEAR(wahp.OutletAirEnthalpy, 43970.75 - (17156.275 / 1.0), 0.1);
+    EXPECT_NEAR(wahp.OutletAirDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate = ActualAirflow;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate = ActualAirflow;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 1.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.85781 * 0.5, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 16000 * 0.89755 * 0.5, 0.1);
+    EXPECT_EQ(wahp.AirMassFlowRate, 1.0);
+    EXPECT_NEAR(wahp.QLoadTotal, 20000 * 0.85781 * 0.5, 0.1);
+    EXPECT_NEAR(wahp.QSensible, 16000 * 0.89755 * 0.5, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 2853.98 * 0.85781 * 0.5, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, 43970.75);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 26.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 26.0 - (14360.848 / 1.0 / CpAir), 0.0001);
     EXPECT_NEAR(
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy, (43970.75 - (17156.275 / 1.0)) * 0.5 + 43970.75 * 0.5, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 18.95267, 0.0001);
+        wahp.OutletAirEnthalpy, (43970.75 - (17156.275 / 1.0)) * 0.5 + 43970.75 * 0.5, 0.1);
+    EXPECT_NEAR(wahp.OutletAirDBTemp, 18.95267, 0.0001);
 
     HPNum = 2;
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).plantLoc.loopNum = 2;
+    auto &wahp2 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum);
+    
+    wahp2.plantLoc.loopNum = 2;
     state->dataPlnt->PlantLoop(2).Name = "HotWaterLoop";
     state->dataPlnt->PlantLoop(2).FluidName = "WATER";
     state->dataPlnt->PlantLoop(2).glycol = Fluid::GetWater(*state);
-    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).Name;
-    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WAHPPlantType;
-    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum;
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate = DesignWaterflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate = DesignWaterflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMax = DesignWaterflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMaxAvail =
-        DesignWaterflow;
-
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Temp = 35.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Enthalpy = 43950.0;
-
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate = ActualAirflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Temp = 15.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).HumRat = 0.004;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Enthalpy = PsyHFnTdbW(15.0, 0.004);
+    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = wahp2.Name;
+    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type = wahp2.coilPlantType;
+    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = wahp2.WaterInletNodeNum;
+
+    wahp2.DesignWaterMassFlowRate = DesignWaterflow;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRate = DesignWaterflow;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRateMax = DesignWaterflow;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRateMaxAvail = DesignWaterflow;
+
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).Temp = 35.0;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).Enthalpy = 43950.0;
+
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = ActualAirflow;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).Temp = 15.0;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).HumRat = 0.004;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).Enthalpy = PsyHFnTdbW(15.0, 0.004);
 
     CpAir = PsyCpAirFnW(0.004);
     // cycling fan
@@ -507,67 +509,68 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimple_TestAirFlow)
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
 
     PartLoadRatio = 1.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate =
         ActualAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 1.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.981844, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 20000 * 0.981844, 0.1);
+    EXPECT_EQ(wahp2.AirMassFlowRate, 1.0);
+    EXPECT_NEAR(wahp2.QLoadTotal, 20000 * 0.981844, 0.1);
+    EXPECT_NEAR(wahp2.QSensible, 20000 * 0.981844, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 6315.01766 * 0.981844, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, PsyHFnTdbW(15.0, 0.004));
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 15.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy, PsyHFnTdbW(15.0, 0.004) + (19636.8798 / 1.0), 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
+    EXPECT_NEAR(wahp2.OutletAirEnthalpy, PsyHFnTdbW(15.0, 0.004) + (19636.8798 / 1.0), 0.1);
+    EXPECT_NEAR(wahp2.OutletAirDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate =
         ActualAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 0.5);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.981844 * 0.5, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 20000 * 0.981844 * 0.5, 0.1);
+    EXPECT_EQ(wahp2.AirMassFlowRate, 0.5);
+    EXPECT_NEAR(wahp2.QLoadTotal, 20000 * 0.981844 * 0.5, 0.1);
+    EXPECT_NEAR(wahp2.QSensible, 20000 * 0.981844 * 0.5, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 6315.01766 * 0.981844 * 0.5, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, PsyHFnTdbW(15.0, 0.004));
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 15.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy, PsyHFnTdbW(15.0, 0.004) + (19636.8798 / 1.0), 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
+    EXPECT_NEAR(wahp2.OutletAirEnthalpy, PsyHFnTdbW(15.0, 0.004) + (19636.8798 / 1.0), 0.1);
+    EXPECT_NEAR(wahp2.OutletAirDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
 
     // constant fan
     fanOp = HVAC::FanOp::Continuous;
     PartLoadRatio = 1.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate =
         ActualAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 1.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.981844, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 20000 * 0.981844, 0.1);
+    EXPECT_EQ(wahp2.AirMassFlowRate, 1.0);
+    EXPECT_NEAR(wahp2.QLoadTotal, 20000 * 0.981844, 0.1);
+    EXPECT_NEAR(wahp2.QSensible, 20000 * 0.981844, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 6315.01766 * 0.981844, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, PsyHFnTdbW(15.0, 0.004));
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 15.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy, PsyHFnTdbW(15.0, 0.004) + (19636.8798 / 1.0), 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
+    EXPECT_NEAR(wahp2.OutletAirEnthalpy, PsyHFnTdbW(15.0, 0.004) + (19636.8798 / 1.0), 0.1);
+    EXPECT_NEAR(wahp2.OutletAirDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate = ActualAirflow;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = ActualAirflow;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirMassFlowRate, 1.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QLoadTotal, 20000 * 0.981844 * 0.5, 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).QSensible, 20000 * 0.981844 * 0.5, 0.1);
+    EXPECT_EQ(wahp2.AirMassFlowRate, 1.0);
+    EXPECT_NEAR(wahp2.QLoadTotal, 20000 * 0.981844 * 0.5, 0.1);
+    EXPECT_NEAR(wahp2.QSensible, 20000 * 0.981844 * 0.5, 0.1);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->Winput, 6315.01766 * 0.981844 * 0.5, 0.1);
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletEnth, PsyHFnTdbW(15.0, 0.004));
     EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->LoadSideInletDBTemp, 15.0);
     EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->LoadSideOutletDBTemp, 15.0 + (19636.8798 / 1.0 / CpAir), 0.0001);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirEnthalpy,
+    EXPECT_NEAR(wahp2.OutletAirEnthalpy,
                 (PsyHFnTdbW(15.0, 0.004) + (19636.8798 / 1.0)) * 0.5 + 0.5 * PsyHFnTdbW(15.0, 0.004),
                 0.1);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletAirDBTemp, 24.69937, 0.0001);
+
+    EXPECT_NEAR(wahp2.OutletAirDBTemp, 24.69937, 0.0001);
 
     // test CheckSimpleWAHPRatedCurvesOutputs with null pointers
     HPNum = 1;
@@ -738,21 +741,20 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimple_TestWaterFlowControl)
 
     int HPNum(1);
     Real64 DesignAirflow(2.0);
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Temp = 5.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Enthalpy = 44650.0;
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate = 15.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMax =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMaxAvail =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate;
-
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate = DesignAirflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Temp = 26.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).HumRat = 0.007;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Enthalpy = 43970.75;
+
+    auto &wahp = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum);
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).Temp = 5.0;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).Enthalpy = 44650.0;
+
+    wahp.DesignWaterMassFlowRate = 15.0;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRate = wahp.DesignWaterMassFlowRate;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRateMax = wahp.DesignWaterMassFlowRate;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRateMaxAvail = wahp.DesignWaterMassFlowRate;
+
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate = DesignAirflow;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).Temp = 26.0;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).HumRat = 0.007;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).Enthalpy = 43970.75;
 
     state->dataPlnt->TotNumLoops = 2;
     state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops);
@@ -769,12 +771,9 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimple_TestWaterFlowControl)
     state->dataPlnt->PlantLoop(1).Name = "ChilledWaterLoop";
     state->dataPlnt->PlantLoop(1).FluidName = "WATER";
     state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state);
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).Name;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WAHPPlantType;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = wahp.Name;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type = wahp.coilPlantType;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = wahp.WaterInletNodeNum;
 
     HVAC::CompressorOp compressorOp = HVAC::CompressorOp::On;
     HVAC::FanOp fanOp = HVAC::FanOp::Cycling;
@@ -783,143 +782,129 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimple_TestWaterFlowControl)
     Real64 LatentLoad(0.0);
     Real64 PartLoadRatio(1.0);
     Real64 OnOffAirFlowRatio(1.0);
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).plantLoc.loopNum = 1;
+    wahp.plantLoc.loopNum = 1;
 
     state->dataEnvrn->OutBaroPress = 101325.0;
 
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 15.0);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 5.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 5.20387, 0.00001);
+    EXPECT_EQ(wahp.WaterMassFlowRate, 15.0);
+    EXPECT_EQ(wahp.InletWaterTemp, 5.0);
+    EXPECT_NEAR(wahp.OutletWaterTemp, 5.20387, 0.00001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 15.0);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 5.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 5.10193, 0.00001);
+    EXPECT_EQ(wahp.WaterMassFlowRate, 15.0);
+    EXPECT_EQ(wahp.InletWaterTemp, 5.0);
+    EXPECT_NEAR(wahp.OutletWaterTemp, 5.10193, 0.00001);
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterCyclingMode = HVAC::WaterFlow::Cycling;
+    wahp.WaterCyclingMode = HVAC::WaterFlow::Cycling;
     PartLoadRatio = 1.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 15.0);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 5.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 5.20387, 0.00001);
+    EXPECT_EQ(wahp.WaterMassFlowRate, 15.0);
+    EXPECT_EQ(wahp.InletWaterTemp, 5.0);
+    EXPECT_NEAR(wahp.OutletWaterTemp, 5.20387, 0.00001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 7.5);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 5.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 5.20387, 0.00001);
+    EXPECT_EQ(wahp.WaterMassFlowRate, 7.5);
+    EXPECT_EQ(wahp.InletWaterTemp, 5.0);
+    EXPECT_NEAR(wahp.OutletWaterTemp, 5.20387, 0.00001);
 
     // test reduced flow at coil water inlet node
     PartLoadRatio = 0.25;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
+    state->dataLoopNodes->Node(wahp.AirInletNodeNum).MassFlowRate =
         DesignAirflow * PartLoadRatio;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate = 3.75;
+    state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRate = 3.75;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPCoolingSimple(*state, HPNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 3.75);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 5.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 5.20387, 0.00001);
+    EXPECT_EQ(wahp.WaterMassFlowRate, 3.75);
+    EXPECT_EQ(wahp.InletWaterTemp, 5.0);
+    EXPECT_NEAR(wahp.OutletWaterTemp, 5.20387, 0.00001);
     UpdateSimpleWatertoAirHP(*state, HPNum);
-    EXPECT_EQ(state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate, 3.75);
-    EXPECT_EQ(state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterOutletNodeNum).MassFlowRate, 3.75);
-    EXPECT_NEAR(state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterOutletNodeNum).Temp, 5.20387, 0.00001);
+    EXPECT_EQ(state->dataLoopNodes->Node(wahp.WaterInletNodeNum).MassFlowRate, 3.75);
+    EXPECT_EQ(state->dataLoopNodes->Node(wahp.WaterOutletNodeNum).MassFlowRate, 3.75);
+    EXPECT_NEAR(state->dataLoopNodes->Node(wahp.WaterOutletNodeNum).Temp, 5.20387, 0.00001);
 
     HPNum = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).plantLoc.loopNum = 2;
+    auto &wahp2 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum);
+    wahp2.plantLoc.loopNum = 2;
     state->dataPlnt->PlantLoop(2).Name = "HotWaterLoop";
     state->dataPlnt->PlantLoop(2).FluidName = "WATER";
     state->dataPlnt->PlantLoop(2).glycol = Fluid::GetWater(*state);
-    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).Name;
-    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WAHPPlantType;
-    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum;
-
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Temp = 35.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).Enthalpy = 43950.0;
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate = 15.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMax =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRateMaxAvail =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate;
-
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate = DesignAirflow;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Temp = 15.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).HumRat = 0.004;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).Enthalpy = PsyHFnTdbW(15.0, 0.004);
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).DesignWaterMassFlowRate = 15.0;
+    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = wahp2.Name;
+    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type = wahp2.coilPlantType;
+    state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = wahp2.WaterInletNodeNum;
+
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).Temp = 35.0;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).Enthalpy = 43950.0;
+
+    wahp2.DesignWaterMassFlowRate = 15.0;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRate = wahp2.DesignWaterMassFlowRate;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRateMax = wahp2.DesignWaterMassFlowRate;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRateMaxAvail = wahp2.DesignWaterMassFlowRate;
+
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = DesignAirflow;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).Temp = 15.0;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).HumRat = 0.004;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).Enthalpy = PsyHFnTdbW(15.0, 0.004);
+
+    wahp.DesignWaterMassFlowRate = 15.0;
 
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
 
     PartLoadRatio = 1.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 15.0);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 35.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 34.50472, 0.00001);
+    EXPECT_EQ(wahp2.WaterMassFlowRate, 15.0);
+    EXPECT_EQ(wahp2.InletWaterTemp, 35.0);
+    EXPECT_NEAR(wahp2.OutletWaterTemp, 34.50472, 0.00001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 15.0);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 35.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 34.75236, 0.00001);
+    EXPECT_EQ(wahp2.WaterMassFlowRate, 15.0);
+    EXPECT_EQ(wahp2.InletWaterTemp, 35.0);
+    EXPECT_NEAR(wahp2.OutletWaterTemp, 34.75236, 0.00001);
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterCyclingMode = HVAC::WaterFlow::Cycling;
+    wahp2.WaterCyclingMode = HVAC::WaterFlow::Cycling;
     PartLoadRatio = 1.0;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 15.0);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 35.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 34.50472, 0.00001);
+    EXPECT_EQ(wahp2.WaterMassFlowRate, 15.0);
+    EXPECT_EQ(wahp2.InletWaterTemp, 35.0);
+    EXPECT_NEAR(wahp2.OutletWaterTemp, 34.50472, 0.00001);
 
     PartLoadRatio = 0.5;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 7.5);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 35.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 34.50472, 0.00001);
+    EXPECT_EQ(wahp2.WaterMassFlowRate, 7.5);
+    EXPECT_EQ(wahp2.InletWaterTemp, 35.0);
+    EXPECT_NEAR(wahp2.OutletWaterTemp, 34.50472, 0.00001);
 
     // test reduced flow at coil water inlet node
     PartLoadRatio = 0.25;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).AirInletNodeNum).MassFlowRate =
-        DesignAirflow * PartLoadRatio;
-    state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate = 3.75;
+    state->dataLoopNodes->Node(wahp2.AirInletNodeNum).MassFlowRate = DesignAirflow * PartLoadRatio;
+    state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRate = 3.75;
     InitSimpleWatertoAirHP(*state, HPNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, FirstHVACIteration);
     CalcHPHeatingSimple(*state, HPNum, fanOp, SensLoad, compressorOp, PartLoadRatio, OnOffAirFlowRatio);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterMassFlowRate, 3.75);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).InletWaterTemp, 35.0);
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).OutletWaterTemp, 34.50472, 0.00001);
+    EXPECT_EQ(wahp2.WaterMassFlowRate, 3.75);
+    EXPECT_EQ(wahp2.InletWaterTemp, 35.0);
+    EXPECT_NEAR(wahp2.OutletWaterTemp, 34.50472, 0.00001);
     UpdateSimpleWatertoAirHP(*state, HPNum);
-    EXPECT_EQ(state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterInletNodeNum).MassFlowRate, 3.75);
-    EXPECT_EQ(state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterOutletNodeNum).MassFlowRate, 3.75);
-    EXPECT_NEAR(
-        state->dataLoopNodes->Node(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).WaterOutletNodeNum).Temp, 34.50472, 0.00001);
+    EXPECT_EQ(state->dataLoopNodes->Node(wahp2.WaterInletNodeNum).MassFlowRate, 3.75);
+    EXPECT_EQ(state->dataLoopNodes->Node(wahp2.WaterOutletNodeNum).MassFlowRate, 3.75);
+    EXPECT_NEAR(state->dataLoopNodes->Node(wahp2.WaterOutletNodeNum).Temp, 34.50472, 0.00001);
 }
 
 TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_CheckSimpleWAHPRatedCurvesOutputs)
@@ -927,7 +912,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_CheckSimpleWAHPRatedCurve
     int HPNum(2);
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP.allocate(HPNum);
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).Name = "WAHP";
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPType = WatertoAirHP::Cooling;
+    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).coilType = HVAC::CoilType::CoolingWAHPSimple;
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedAirVolFlowRate = AutoSize;
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolTotal = AutoSize;
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolSens = AutoSize;
@@ -997,7 +982,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_CheckSimpleWAHPRatedCurve
     EXPECT_TRUE(compare_err_stream("", true));
 
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).Name = "WAHP 2";
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPType = WatertoAirHP::Cooling;
+    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).coilType = HVAC::CoilType::CoolingWAHPSimple;
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedAirVolFlowRate = AutoSize;
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolTotal = AutoSize;
     state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolSens = AutoSize;
@@ -1097,30 +1082,36 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     state->dataSize->DesDayWeath.allocate(1);
     state->dataSize->DesDayWeath(1).Temp.allocate(24);
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPType = WatertoAirHP::Cooling;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedAirVolFlowRate = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolTotal = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolSens = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedWaterVolFlowRate = 0.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterInletNodeNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterOutletNodeNum = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedEntWaterTemp = 30.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedEntAirWetbulbTemp = 19.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedEntAirDrybulbTemp = 27.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).CompanionHeatingCoilNum = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPType = WatertoAirHP::Heating;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedAirVolFlowRate = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeat = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedWaterVolFlowRate = 0.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterInletNodeNum = 3;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterOutletNodeNum = 4;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedEntWaterTemp = 20.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedEntAirDrybulbTemp = 20.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).CompanionCoolingCoilNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatioRatedHeatRatedTotCoolCap = 1.23;
+    auto &wahp1 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1);
+    wahp1.Name = "WAHP Coolng Coil";
+    wahp1.coilType = HVAC::CoilType::CoolingWAHPSimple;
+    wahp1.coilReportNum = ReportCoilSelection::getReportIndex(*state, wahp1.Name, wahp1.coilType);
+    wahp1.RatedAirVolFlowRate = AutoSize;
+    wahp1.RatedCapCoolTotal = AutoSize;
+    wahp1.RatedCapCoolSens = AutoSize;
+    wahp1.RatedWaterVolFlowRate = 0.0;
+    wahp1.WaterInletNodeNum = 1;
+    wahp1.WaterOutletNodeNum = 2;
+    wahp1.RatedEntWaterTemp = 30.0;
+    wahp1.RatedEntAirWetbulbTemp = 19.0;
+    wahp1.RatedEntAirDrybulbTemp = 27.0;
+    wahp1.CompanionHeatingCoilNum = 2;
+    wahp1.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
+
+    auto &wahp2 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2);
+    wahp2.Name = "WAHP Heating Coil";
+    wahp2.coilType = HVAC::CoilType::HeatingWAHPSimple;
+    wahp2.coilReportNum = ReportCoilSelection::getReportIndex(*state, wahp2.Name, wahp2.coilType);
+    wahp2.RatedAirVolFlowRate = AutoSize;
+    wahp2.RatedCapHeat = AutoSize;
+    wahp2.RatedWaterVolFlowRate = 0.0;
+    wahp2.WaterInletNodeNum = 3;
+    wahp2.WaterOutletNodeNum = 4;
+    wahp2.RatedEntWaterTemp = 20.0;
+    wahp2.RatedEntAirDrybulbTemp = 20.0;
+    wahp2.CompanionCoolingCoilNum = 1;
+    wahp2.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
+    wahp2.RatioRatedHeatRatedTotCoolCap = 1.23;
 
     state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).DesCoolVolFlow = 0.20;
     state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).DesHeatVolFlow = 0.20;
@@ -1224,14 +1215,14 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     curve5->inputLimits[3].max = 38;
 
     // performance curve coefficients
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).TotalCoolCapCurve = curve1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).SensCoolCapCurve = curve2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).CoolPowCurve = curve3;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).HeatCapCurve = curve4;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).HeatPowCurve = curve5;
+    wahp1.TotalCoolCapCurve = curve1;
+    wahp1.SensCoolCapCurve = curve2;
+    wahp1.CoolPowCurve = curve3;
+    wahp2.HeatCapCurve = curve4;
+    wahp2.HeatPowCurve = curve5;
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCOPCoolAtRatedCdts = 5.12;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCOPHeatAtRatedCdts = 3.0;
+    wahp1.RatedCOPCoolAtRatedCdts = 5.12;
+    wahp2.RatedCOPHeatAtRatedCdts = 3.0;
 
     state->dataSize->DesDayWeath(1).Temp(15) = 32.0;
     state->dataEnvrn->StdBaroPress = 101325.0;
@@ -1251,21 +1242,15 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     loopsidebranch.TotalComponents = 2;
     loopsidebranch.Comp.allocate(2);
 
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).Name;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPPlantType;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterInletNodeNum;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loopNum = 1;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = wahp1.Name;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type = wahp1.coilPlantType;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = wahp1.WaterInletNodeNum;
+    wahp1.plantLoc.loopNum = 1;
 
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).Name;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPPlantType;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterInletNodeNum;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loopNum = 1;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Name = wahp2.Name;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Type = wahp2.coilPlantType;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).NodeNumIn = wahp2.WaterInletNodeNum;
+    wahp2.plantLoc.loopNum = 1;
 
     // plant loop design leaving water temperature (design entering water temperature for WAHP coil)
     state->dataSize->NumPltSizInput = 1;
@@ -1276,28 +1261,28 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     WaterToAirHeatPumpSimple::SizeHVACWaterToAir(*state, 1);
     WaterToAirHeatPumpSimple::SizeHVACWaterToAir(*state, 2);
 
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolAtRatedCdts /
-                    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedPowerCoolAtRatedCdts,
+    EXPECT_NEAR(wahp1.RatedCapCoolAtRatedCdts /
+                    wahp1.RatedPowerCoolAtRatedCdts,
                 5.12,
                 0.00001);
 
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolTotal -
-                    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolAtRatedCdts,
+    EXPECT_NEAR(wahp1.RatedCapCoolTotal -
+                    wahp1.RatedCapCoolAtRatedCdts,
                 0.0,
                 0.00001);
 
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeatAtRatedCdts /
-                    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedPowerHeatAtRatedCdts,
+    EXPECT_NEAR(wahp2.RatedCapHeatAtRatedCdts /
+                    wahp2.RatedPowerHeatAtRatedCdts,
                 3.0,
                 0.00001);
 
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeat -
-                    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeatAtRatedCdts,
+    EXPECT_NEAR(wahp2.RatedCapHeat -
+                    wahp2.RatedCapHeatAtRatedCdts,
                 0.0,
                 0.00001);
 
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeatAtRatedCdts /
-                    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolAtRatedCdts,
+    EXPECT_NEAR(wahp2.RatedCapHeatAtRatedCdts /
+                    wahp1.RatedCapCoolAtRatedCdts,
                 1.23,
                 0.00001);
 }
@@ -1321,30 +1306,36 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     state->dataSize->DesDayWeath.allocate(1);
     state->dataSize->DesDayWeath(1).Temp.allocate(24);
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPType = WatertoAirHP::Cooling;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedAirVolFlowRate = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolTotal = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolSens = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedWaterVolFlowRate = 0.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterInletNodeNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterOutletNodeNum = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedEntWaterTemp = 30.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedEntAirWetbulbTemp = 19.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedEntAirDrybulbTemp = 27.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).CompanionHeatingCoilNum = 2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
-
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPType = WatertoAirHP::Heating;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedAirVolFlowRate = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeat = AutoSize;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedWaterVolFlowRate = 0.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterInletNodeNum = 3;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterOutletNodeNum = 4;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedEntWaterTemp = 20.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedEntAirDrybulbTemp = 20.0;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).CompanionCoolingCoilNum = 1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatioRatedHeatRatedTotCoolCap = 1.23;
+    auto &wahp1 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1);
+    wahp1.Name = "WAHP Cooling Coil";
+    wahp1.coilType = HVAC::CoilType::CoolingWAHPSimple;
+    wahp1.coilReportNum = ReportCoilSelection::getReportIndex(*state, wahp1.Name, wahp1.coilType);
+    wahp1.RatedAirVolFlowRate = AutoSize;
+    wahp1.RatedCapCoolTotal = AutoSize;
+    wahp1.RatedCapCoolSens = AutoSize;
+    wahp1.RatedWaterVolFlowRate = 0.0;
+    wahp1.WaterInletNodeNum = 1;
+    wahp1.WaterOutletNodeNum = 2;
+    wahp1.RatedEntWaterTemp = 30.0;
+    wahp1.RatedEntAirWetbulbTemp = 19.0;
+    wahp1.RatedEntAirDrybulbTemp = 27.0;
+    wahp1.CompanionHeatingCoilNum = 2;
+    wahp1.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPCoolingEquationFit;
+
+    auto &wahp2 = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2);
+    wahp2.Name = "WAHP Heating Coil";
+    wahp2.coilType = HVAC::CoilType::HeatingWAHPSimple;
+    wahp2.coilReportNum = ReportCoilSelection::getReportIndex(*state, wahp2.Name, wahp2.coilType);
+    wahp2.RatedAirVolFlowRate = AutoSize;
+    wahp2.RatedCapHeat = AutoSize;
+    wahp2.RatedWaterVolFlowRate = 0.0;
+    wahp2.WaterInletNodeNum = 3;
+    wahp2.WaterOutletNodeNum = 4;
+    wahp2.RatedEntWaterTemp = 20.0;
+    wahp2.RatedEntAirDrybulbTemp = 20.0;
+    wahp2.CompanionCoolingCoilNum = 1;
+    wahp2.coilPlantType = DataPlant::PlantEquipmentType::CoilWAHPHeatingEquationFit;
+    wahp2.RatioRatedHeatRatedTotCoolCap = 1.23;
 
     state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).DesCoolVolFlow = 0.20;
     state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).DesHeatVolFlow = 0.0004;
@@ -1448,14 +1439,14 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     curve5->inputLimits[3].max = 38;
 
     // performance curve coefficients
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).TotalCoolCapCurve = curve1;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).SensCoolCapCurve = curve2;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).CoolPowCurve = curve3;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).HeatCapCurve = curve4;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).HeatPowCurve = curve5;
+    wahp1.TotalCoolCapCurve = curve1;
+    wahp1.SensCoolCapCurve = curve2;
+    wahp1.CoolPowCurve = curve3;
+    wahp2.HeatCapCurve = curve4;
+    wahp2.HeatPowCurve = curve5;
 
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCOPCoolAtRatedCdts = 5.12;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCOPHeatAtRatedCdts = 3.0;
+    wahp1.RatedCOPCoolAtRatedCdts = 5.12;
+    wahp2.RatedCOPHeatAtRatedCdts = 3.0;
 
     state->dataSize->DesDayWeath(1).Temp(15) = 32.0;
     state->dataEnvrn->StdBaroPress = 101325.0;
@@ -1475,21 +1466,15 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     loopsidebranch.TotalComponents = 2;
     loopsidebranch.Comp.allocate(2);
 
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).Name;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WAHPPlantType;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterInletNodeNum;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loopNum = 1;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Name = wahp1.Name;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).Type = wahp1.coilPlantType;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = wahp1.WaterInletNodeNum;
+    wahp1.plantLoc.loopNum = 1;
 
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Name =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).Name;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Type =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WAHPPlantType;
-    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).NodeNumIn =
-        state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterInletNodeNum;
-    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loopNum = 1;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Name = wahp2.Name;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Type = wahp2.coilPlantType;
+    state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).NodeNumIn = wahp2.WaterInletNodeNum;
+    wahp2.plantLoc.loopNum = 1;
 
     // plant loop design leaving water temperature (design entering water temperature for WAHP coil)
     state->dataSize->NumPltSizInput = 1;
@@ -1500,10 +1485,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo
     WaterToAirHeatPumpSimple::SizeHVACWaterToAir(*state, 1);
     WaterToAirHeatPumpSimple::SizeHVACWaterToAir(*state, 2);
 
-    EXPECT_NEAR(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).RatedCapHeatAtRatedCdts /
-                    state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).RatedCapCoolAtRatedCdts,
-                1.23,
-                0.00001);
+    EXPECT_NEAR(wahp2.RatedCapHeatAtRatedCdts / wahp1.RatedCapCoolAtRatedCdts, 1.23, 0.00001);
 }
 
 TEST_F(EnergyPlusFixture, EquationFit_Initialization)
@@ -1611,7 +1593,8 @@ TEST_F(EnergyPlusFixture, EquationFit_Initialization)
 
     WaterToAirHeatPumpSimple::GetSimpleWatertoAirHPInput(*state);
     int HPNum(1);
-    EXPECT_EQ(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum).Name, "SYS 5 HEAT PUMP COOLING MODE");
+    auto &wahp = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum);
+    EXPECT_EQ(wahp.Name, "SYS 5 HEAT PUMP COOLING MODE");
     auto &thisCoil(state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(HPNum));
     EXPECT_NEAR(thisCoil.RatedCOPCoolAtRatedCdts, 7.00776, 0.01);
 }
diff --git a/tst/EnergyPlus/unit/WindowAC.unit.cc b/tst/EnergyPlus/unit/WindowAC.unit.cc
index f3810e0795b..190e240e57b 100644
--- a/tst/EnergyPlus/unit/WindowAC.unit.cc
+++ b/tst/EnergyPlus/unit/WindowAC.unit.cc
@@ -469,7 +469,7 @@ TEST_F(EnergyPlusFixture, WindowAC_VStest1)
     EXPECT_EQ(compIndex, 1);
 
     // MixTemp = 24.00, MixHumRat = 0.008, SupTemp = 12, SupHumRat = 0.008
-    double constexpr expected_full_airflow = 0.041484382187390034;
+    double constexpr expected_full_airflow = 0.041484382187390034; // Why this level of precision?
     double constexpr expected_full_cap = 622.50474573886743;
 
     auto const &windowAC = state->dataWindowAC->WindAC(compIndex);
@@ -479,13 +479,13 @@ TEST_F(EnergyPlusFixture, WindowAC_VStest1)
 
     auto const &finalZoneSizing = state->dataSize->FinalZoneSizing(1);
 
-    EXPECT_NEAR(expected_full_airflow, finalZoneSizing.DesCoolVolFlow, 0.0001);
+    EXPECT_NEAR(expected_full_airflow, finalZoneSizing.DesCoolVolFlow, 0.0001); // Why is this the tolerance?
 
     EXPECT_EQ(windowAC.HVACSizingIndex, 0);
 
-    EXPECT_EQ(windowAC.DXCoilType_Num, HVAC::Coil_CoolingAirToAirVariableSpeed);
-    ASSERT_GT(windowAC.DXCoilIndex, 0);
-    auto const &varSpeedCoil = state->dataVariableSpeedCoils->VarSpeedCoil(windowAC.DXCoilIndex);
+    EXPECT_ENUM_EQ(windowAC.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    ASSERT_GT(windowAC.CoilNum, 0);
+    auto const &varSpeedCoil = state->dataVariableSpeedCoils->VarSpeedCoil(windowAC.CoilNum);
 
     // check Sizing
     EXPECT_NEAR(expected_full_airflow, windowAC.MaxAirVolFlow, 0.0001);
@@ -964,9 +964,9 @@ TEST_F(EnergyPlusFixture, WindowAC_DesignSpecificationZoneHVACSizing)
     EXPECT_EQ(DataSizing::FractionOfAutosizedCoolingCapacity, zoneHVACSizing.CoolingCapMethod);
     EXPECT_EQ(scaler_cooling_cap, zoneHVACSizing.ScaledCoolingCapacity);
 
-    EXPECT_EQ(windowAC.DXCoilType_Num, HVAC::Coil_CoolingAirToAirVariableSpeed);
-    ASSERT_GT(windowAC.DXCoilIndex, 0);
-    auto const &varSpeedCoil = state->dataVariableSpeedCoils->VarSpeedCoil(windowAC.DXCoilIndex);
+    EXPECT_ENUM_EQ(windowAC.coilType, HVAC::CoilType::CoolingDXVariableSpeed);
+    ASSERT_GT(windowAC.CoilNum, 0);
+    auto const &varSpeedCoil = state->dataVariableSpeedCoils->VarSpeedCoil(windowAC.CoilNum);
 
     // check Sizing
     EXPECT_NEAR(expected_full_airflow * scaler_cooling_saf, windowAC.MaxAirVolFlow, 0.0001);