From 701f4baad325ca73c7bc26a1eb6ab1f02d219fbf Mon Sep 17 00:00:00 2001 From: Julien Marrec Date: Thu, 23 Jan 2025 10:52:31 +0100 Subject: [PATCH] [chore] Typo cooing -> cooling ```bash rg dataCoilCooingDX -l | xargs -I @ sed -i 's/dataCoilCooingDX/dataCoilCoolingDX/g' @ rg cooing -l | xargs -I @ sed -i 's/cooing/cooling/g' @ rg Cooing -l | xargs -I @ sed -i 's/Cooing/Cooling/g' @ ``` --- .../introduction-004.tex | 2 +- .../coils.tex | 4 +- .../air-system-compound-component-groups.tex | 2 +- .../centralheatpumpsystem.tex | 2 +- .../src/overview/group-unitary-equipment.tex | 2 +- src/EnergyPlus/AirflowNetwork/src/Solver.cpp | 6 +- src/EnergyPlus/ChillerReformulatedEIR.cc | 2 +- src/EnergyPlus/Coils/CoilCoolingDX.cc | 36 ++++----- src/EnergyPlus/CostEstimateManager.cc | 14 ++-- src/EnergyPlus/DXCoils.cc | 2 +- src/EnergyPlus/Data/EnergyPlusData.cc | 6 +- src/EnergyPlus/Data/EnergyPlusData.hh | 2 +- src/EnergyPlus/Furnaces.cc | 6 +- src/EnergyPlus/HVACHXAssistedCoolingCoil.cc | 32 ++++---- src/EnergyPlus/HVACManager.cc | 2 +- src/EnergyPlus/HVACUnitaryBypassVAV.cc | 4 +- src/EnergyPlus/HeatRecovery.cc | 6 +- src/EnergyPlus/HeatingCoils.cc | 6 +- src/EnergyPlus/UnitarySystem.cc | 81 ++++++++++--------- src/EnergyPlus/WaterThermalTanks.cc | 16 ++-- .../unit/Coils/CoilCoolingDX.unit.cc | 12 +-- ...CoilCoolingDXCurveFitOperatingMode.unit.cc | 2 +- tst/EnergyPlus/unit/Furnaces.unit.cc | 4 +- tst/EnergyPlus/unit/StandardRatings.unit.cc | 8 +- tst/EnergyPlus/unit/UnitarySystem.unit.cc | 4 +- 25 files changed, 132 insertions(+), 131 deletions(-) diff --git a/doc/auxiliary-programs/src/hvac-performance-curve-fit-tool/introduction-004.tex b/doc/auxiliary-programs/src/hvac-performance-curve-fit-tool/introduction-004.tex index 1837dd4a4e0..0947e54a671 100644 --- a/doc/auxiliary-programs/src/hvac-performance-curve-fit-tool/introduction-004.tex +++ b/doc/auxiliary-programs/src/hvac-performance-curve-fit-tool/introduction-004.tex @@ -16,4 +16,4 @@ \section{Introduction}\label{introduction-002} \caption{Curve Fit Tool Input Interface \protect \label{fig:curve-fit-tool-input-interface}} \end{figure} -The tool can be used for Coil:Cooing:DX:SingleSpeed, Coil:Heating:DX:SingleSpeed, Coil:Cooing:DX:TwoSpeed (high and low speed) , CoilPerformance:DX:Cooling (each stage), and any HVAC equipment that use Biquadratic, Cubic or Quadratic curves. To add this flexibility generic input data labels can be populated by selecting ``Other'' for DX Coil Type input field, located in Cell B3 in Figure~\ref{fig:curve-fit-tool-input-interface}. +The tool can be used for Coil:Cooling:DX:SingleSpeed, Coil:Heating:DX:SingleSpeed, Coil:Cooling:DX:TwoSpeed (high and low speed) , CoilPerformance:DX:Cooling (each stage), and any HVAC equipment that use Biquadratic, Cubic or Quadratic curves. To add this flexibility generic input data labels can be populated by selecting ``Other'' for DX Coil Type input field, located in Cell B3 in Figure~\ref{fig:curve-fit-tool-input-interface}. diff --git a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex index 4ae205972ed..bc07673af3b 100644 --- a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex +++ b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-001/coils.tex @@ -1252,7 +1252,7 @@ \subsubsection{SHR Calculation Using User Specified SHR Modifier Curves}\label{s SHR = SH{R_{rated}} \cdot SHRFT\left( {{T_{wb,i}},{T_{db,i}}} \right) \cdot SHRFFF\left( {FF} \right) \end{equation} -The cooing coil outlet air enthalpy is given by: +The cooling coil outlet air enthalpy is given by: \begin{equation} {h_{out}} = {h_{in}} - \frac{{{{\dot Q}_{total}}}}{{\dot m}} @@ -1448,7 +1448,7 @@ \subsubsection{Latent Capacity Degradation}\label{latent-capacity-degradation} \(T_{db,rated}\) is the dry-bulb temperature of air entering the cooling coil at rated conditions (26.7\(^{\circ}\)C) -\(T_{wb,rated}\) is the wet-bulb temperature of air entering the cooing coil at rated conditions (19.4\(^{\circ}\)C). +\(T_{wb,rated}\) is the wet-bulb temperature of air entering the cooling coil at rated conditions (19.4\(^{\circ}\)C). The cooling coil on and off times are then calculated based on the maximum number of cycles per hour and the calculated run-time fraction for the coil. diff --git a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex index 89969ac2832..d331b6b5c4e 100644 --- a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex +++ b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-002/air-system-compound-component-groups.tex @@ -1065,7 +1065,7 @@ \subsubsection{Model Description}\label{model-description-2} If Heating Priority is specified and the total heating requirement in all zones is not equal to zero, then heating is selected as the operating mode. If the total heating requirement is equal to zero and the total cooling requirement is not equal to zero, then cooling is selected as the operating mode. If the total cooling requirement and total heating requirement are equal to zero then the zones are allowed to float (no heating or cooling provided). -If Zone Priority is specified and the total number of zones requiring cooling is greater than the total number of zones requiring heating, then cooling is selected as the operating mode. If the total number of zones requiring heating is greater than the total number of zones requiring cooling, then heating is selected as the operating mode. If the total number of zones requiring cooling is equal to the total number of zones requiring heating, then the magnitude of the total cooling and heating requirements for all zones sets the operating mode. In this case, if the magnitudes of the cooling and heating requirements are zero, then the zones are allowed to float (no heating or cooing provided). If the magnitudes of the cooling and heating requirements are non-zero and identical, then cooling is selected as the operating mode. +If Zone Priority is specified and the total number of zones requiring cooling is greater than the total number of zones requiring heating, then cooling is selected as the operating mode. If the total number of zones requiring heating is greater than the total number of zones requiring cooling, then heating is selected as the operating mode. If the total number of zones requiring cooling is equal to the total number of zones requiring heating, then the magnitude of the total cooling and heating requirements for all zones sets the operating mode. In this case, if the magnitudes of the cooling and heating requirements are zero, then the zones are allowed to float (no heating or cooling provided). If the magnitudes of the cooling and heating requirements are non-zero and identical, then cooling is selected as the operating mode. \paragraph{Calculation of Bypass Duct Mixer Node Conditions}\label{calculation-of-bypass-duct-mixer-node-conditions} diff --git a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-003/centralheatpumpsystem.tex b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-003/centralheatpumpsystem.tex index e03854523b1..7d1142d21a0 100644 --- a/doc/engineering-reference/src/simulation-models-encyclopedic-reference-003/centralheatpumpsystem.tex +++ b/doc/engineering-reference/src/simulation-models-encyclopedic-reference-003/centralheatpumpsystem.tex @@ -6,7 +6,7 @@ \subsection{Overview}\label{overview-007} \subsection{Model Description}\label{model-description-004} -The model first determines operating modes based on the cooling and heating loads on the system, and then decides which calculation algorithm is called. It calls the cooling calculation subroutine when cooling load is demanded, the heating calculation subroutine when heating load is demanded, and both cooling and heating calculation subroutines when both cooling and heating loads are demanded, i.e., simultaneous cooing-heating mode. It then calculates mass-weighed temperatures and heat transfer energy. Six different operating modes (0 through 5) are possible: +The model first determines operating modes based on the cooling and heating loads on the system, and then decides which calculation algorithm is called. It calls the cooling calculation subroutine when cooling load is demanded, the heating calculation subroutine when heating load is demanded, and both cooling and heating calculation subroutines when both cooling and heating loads are demanded, i.e., simultaneous cooling-heating mode. It then calculates mass-weighed temperatures and heat transfer energy. Six different operating modes (0 through 5) are possible: 0: off diff --git a/doc/input-output-reference/src/overview/group-unitary-equipment.tex b/doc/input-output-reference/src/overview/group-unitary-equipment.tex index 42ef71a45ff..5804bed40f7 100644 --- a/doc/input-output-reference/src/overview/group-unitary-equipment.tex +++ b/doc/input-output-reference/src/overview/group-unitary-equipment.tex @@ -2968,7 +2968,7 @@ \subsubsection{Inputs}\label{inputs-8-027} \paragraph{Field: Maximum Outlet Air Temperature During Heating Operation}\label{field-maximum-outlet-air-temperature-during-heating-operation} -This numeric field defines the maximum outlet air temperature leaving the system when the unit is operating to provide heating. Values are specified in degrees Celsius and must be greater than 0. The default value is 50°C. This value must be greater than or equal to the minimum outlet air temperature during cooing operation. +This numeric field defines the maximum outlet air temperature leaving the system when the unit is operating to provide heating. Values are specified in degrees Celsius and must be greater than 0. The default value is 50°C. This value must be greater than or equal to the minimum outlet air temperature during cooling operation. \paragraph{Field: Dehumidification Control Type}\label{field-dehumidification-control-type-5-000} diff --git a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp index 12cf5a25e10..f9aefdf21f6 100644 --- a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp +++ b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp @@ -10521,10 +10521,10 @@ namespace AirflowNetwork { } else { // Replace the convenience function with in-place code std::string mycoil = DisSysCompCoilData(i).name; - auto it = std::find_if(m_state.dataCoilCooingDX->coilCoolingDXs.begin(), - m_state.dataCoilCooingDX->coilCoolingDXs.end(), + auto it = std::find_if(m_state.dataCoilCoolingDX->coilCoolingDXs.begin(), + m_state.dataCoilCoolingDX->coilCoolingDXs.end(), [&mycoil](const CoilCoolingDX &coil) { return coil.name == mycoil; }); - if (it != m_state.dataCoilCooingDX->coilCoolingDXs.end()) { + if (it != m_state.dataCoilCoolingDX->coilCoolingDXs.end()) { // Set the airloop number on the CoilCoolingDX object, which is used to collect the runtime fraction it->airLoopNum = DisSysCompCoilData(i).AirLoopNum; } else { diff --git a/src/EnergyPlus/ChillerReformulatedEIR.cc b/src/EnergyPlus/ChillerReformulatedEIR.cc index 17b9566d825..d6e544997da 100644 --- a/src/EnergyPlus/ChillerReformulatedEIR.cc +++ b/src/EnergyPlus/ChillerReformulatedEIR.cc @@ -1678,7 +1678,7 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state) // Output warning message if negative values are found in the EIRFPLR curve output. Results in Fatal error. if (FoundNegValue) { - ShowWarningError(state, "Energy input to cooing output ratio function of part-load ratio curve shows negative values "); + ShowWarningError(state, "Energy input to cooling output ratio function of part-load ratio curve shows negative values "); ShowContinueError(state, format("for Chiller:Electric:ReformulatedEIR = {}.", equipName)); ShowContinueError(state, "EIR as a function of PLR curve output at various part-load ratios and condenser water temperatures shown below:"); diff --git a/src/EnergyPlus/Coils/CoilCoolingDX.cc b/src/EnergyPlus/Coils/CoilCoolingDX.cc index dd975cdfb6d..e6d7772aad7 100644 --- a/src/EnergyPlus/Coils/CoilCoolingDX.cc +++ b/src/EnergyPlus/Coils/CoilCoolingDX.cc @@ -76,13 +76,13 @@ using namespace EnergyPlus; int CoilCoolingDX::factory(EnergyPlus::EnergyPlusData &state, std::string const &coilName) { - if (state.dataCoilCooingDX->coilCoolingDXGetInputFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXGetInputFlag) { CoilCoolingDX::getInput(state); - state.dataCoilCooingDX->coilCoolingDXGetInputFlag = false; + state.dataCoilCoolingDX->coilCoolingDXGetInputFlag = false; } int handle = -1; std::string coilNameUpper = Util::makeUPPER(coilName); - for (auto const &thisCoil : state.dataCoilCooingDX->coilCoolingDXs) { + for (auto const &thisCoil : state.dataCoilCoolingDX->coilCoolingDXs) { handle++; if (coilNameUpper == Util::makeUPPER(thisCoil.name)) { return handle; @@ -94,7 +94,7 @@ int CoilCoolingDX::factory(EnergyPlus::EnergyPlusData &state, std::string const void CoilCoolingDX::getInput(EnergyPlusData &state) { - int numCoolingCoilDXs = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataCoilCooingDX->coilCoolingDXObjectName); + int numCoolingCoilDXs = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataCoilCoolingDX->coilCoolingDXObjectName); if (numCoolingCoilDXs <= 0) { ShowFatalError(state, R"(No "Coil:Cooling:DX" objects in input file)"); } @@ -103,7 +103,7 @@ void CoilCoolingDX::getInput(EnergyPlusData &state) int NumNumbers; // Number of Numbers for each GetObjectItem call int IOStatus; state.dataInputProcessing->inputProcessor->getObjectItem(state, - state.dataCoilCooingDX->coilCoolingDXObjectName, + state.dataCoilCoolingDX->coilCoolingDXObjectName, coilNum, state.dataIPShortCut->cAlphaArgs, NumAlphas, @@ -123,7 +123,7 @@ void CoilCoolingDX::getInput(EnergyPlusData &state) input_specs.evaporative_condenser_supply_water_storage_tank_name = state.dataIPShortCut->cAlphaArgs(10); CoilCoolingDX thisCoil; thisCoil.instantiateFromInputSpec(state, input_specs); - state.dataCoilCooingDX->coilCoolingDXs.push_back(thisCoil); + state.dataCoilCoolingDX->coilCoolingDXs.push_back(thisCoil); } } @@ -136,7 +136,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo // initialize reclaim heat parameters this->reclaimHeat.Name = this->name; - this->reclaimHeat.SourceType = state.dataCoilCooingDX->coilCoolingDXObjectName; + this->reclaimHeat.SourceType = state.dataCoilCoolingDX->coilCoolingDXObjectName; this->performance = CoilCoolingDXCurveFitPerformance(state, input_data.performance_object_name); @@ -189,7 +189,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo if (!input_data.condensate_collection_water_storage_tank_name.empty()) { WaterManager::SetupTankSupplyComponent(state, this->name, - state.dataCoilCooingDX->coilCoolingDXObjectName, + state.dataCoilCoolingDX->coilCoolingDXObjectName, input_data.condensate_collection_water_storage_tank_name, errorsFound, this->condensateTankIndex, @@ -199,7 +199,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.dataCoilCooingDX->coilCoolingDXObjectName, + state.dataCoilCoolingDX->coilCoolingDXObjectName, input_data.evaporative_condenser_supply_water_storage_tank_name, errorsFound, this->evaporativeCondSupplyTankIndex, @@ -213,7 +213,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo } if (this->availScheduleIndex == 0) { - ShowSevereError(state, std::string{routineName} + state.dataCoilCooingDX->coilCoolingDXObjectName + "=\"" + this->name + "\", invalid"); + ShowSevereError(state, std::string{routineName} + state.dataCoilCoolingDX->coilCoolingDXObjectName + "=\"" + this->name + "\", invalid"); ShowContinueError(state, "...Availability Schedule Name=\"" + input_data.availability_schedule_name + "\"."); errorsFound = true; } @@ -224,7 +224,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo } BranchNodeConnections::TestCompSet(state, - state.dataCoilCooingDX->coilCoolingDXObjectName, + state.dataCoilCoolingDX->coilCoolingDXObjectName, this->name, input_data.evaporator_inlet_node_name, input_data.evaporator_outlet_node_name, @@ -232,7 +232,7 @@ void CoilCoolingDX::instantiateFromInputSpec(EnergyPlusData &state, const CoilCo if (errorsFound) { ShowFatalError(state, - std::string{routineName} + "Errors found in getting " + state.dataCoilCooingDX->coilCoolingDXObjectName + + std::string{routineName} + "Errors found in getting " + state.dataCoilCoolingDX->coilCoolingDXObjectName + " input. Preceding condition(s) causes termination."); } } @@ -805,7 +805,7 @@ void CoilCoolingDX::simulate(EnergyPlusData &state, ratedSensCap = this->performance.normalMode.ratedGrossTotalCap * this->normModeNomSpeed().grossRatedSHR; state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state, this->name, - state.dataCoilCooingDX->coilCoolingDXObjectName, + state.dataCoilCoolingDX->coilCoolingDXObjectName, this->performance.normalMode.ratedGrossTotalCap, ratedSensCap, this->performance.normalMode.ratedEvapAirFlowRate, @@ -816,7 +816,7 @@ void CoilCoolingDX::simulate(EnergyPlusData &state, if (this->supplyFanIndex > 0) { state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(state, this->name, - state.dataCoilCooingDX->coilCoolingDXObjectName, + state.dataCoilCoolingDX->coilCoolingDXObjectName, state.dataFans->fans(this->supplyFanIndex)->Name, state.dataFans->fans(this->supplyFanIndex)->type, this->supplyFanIndex); @@ -903,7 +903,7 @@ void CoilCoolingDX::simulate(EnergyPlusData &state, state, dummyEvapOutlet.Temp, dummyEvapOutlet.HumRat, DataEnvironment::StdPressureSeaLevel, "Coil:Cooling:DX::simulate"); state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(state, this->name, - state.dataCoilCooingDX->coilCoolingDXObjectName, + state.dataCoilCoolingDX->coilCoolingDXObjectName, coolingRate, sensCoolingRate, ratedInletEvapMassFlowRate, @@ -987,7 +987,7 @@ void PopulateCoolingCoilStandardRatingInformation(InputOutputFile &eio, void CoilCoolingDX::reportAllStandardRatings(EnergyPlusData &state) { - if (!state.dataCoilCooingDX->coilCoolingDXs.empty()) { + if (!state.dataCoilCoolingDX->coilCoolingDXs.empty()) { Real64 constexpr ConvFromSIToIP(3.412141633); // Conversion from SI to IP [3.412 Btu/hr-W] if (state.dataHVACGlobal->StandardRatingsMyCoolOneTimeFlag) { static constexpr std::string_view Format_994( @@ -998,7 +998,7 @@ void CoilCoolingDX::reportAllStandardRatings(EnergyPlusData &state) print(state.files.eio, "{}\n", Format_994); state.dataHVACGlobal->StandardRatingsMyCoolOneTimeFlag = false; } - for (auto &coil : state.dataCoilCooingDX->coilCoolingDXs) { + for (auto &coil : state.dataCoilCoolingDX->coilCoolingDXs) { coil.performance.calcStandardRatings210240(state); PopulateCoolingCoilStandardRatingInformation(state.files.eio, coil.name, @@ -1141,5 +1141,5 @@ void CoilCoolingDX::reportAllStandardRatings(EnergyPlusData &state) "4 - Value for the Full Speed of the coil."); } } - state.dataCoilCooingDX->stillNeedToReportStandardRatings = false; + state.dataCoilCoolingDX->stillNeedToReportStandardRatings = false; } diff --git a/src/EnergyPlus/CostEstimateManager.cc b/src/EnergyPlus/CostEstimateManager.cc index 9025dd4e95f..fea2c41eee9 100644 --- a/src/EnergyPlus/CostEstimateManager.cc +++ b/src/EnergyPlus/CostEstimateManager.cc @@ -718,7 +718,7 @@ namespace CostEstimateManager { // Input validation happens before we get to this point // The factory throws a severe error when the coil is not found // Finding the coil like this here to protects against another SevereError being thrown out of context - auto &v = state.dataCoilCooingDX->coilCoolingDXs; + auto &v = state.dataCoilCoolingDX->coilCoolingDXs; auto isInCoils = [&parentObjName](const CoilCoolingDX &coil) { return coil.name == parentObjName; }; auto it = std::find_if(v.begin(), v.end(), isInCoils); if (it != v.end()) { @@ -730,7 +730,7 @@ namespace CostEstimateManager { if (state.dataCostEstimateManager->CostLineItem(Item).PerKiloWattCap > 0.0) { if (WildcardObjNames) { Real64 Qty(0.0); - for (auto const &e : state.dataCoilCooingDX->coilCoolingDXs) + for (auto const &e : state.dataCoilCoolingDX->coilCoolingDXs) Qty += e.performance.normalMode.ratedGrossTotalCap; state.dataCostEstimateManager->CostLineItem(Item).Qty = Qty / 1000.0; state.dataCostEstimateManager->CostLineItem(Item).Units = "kW (tot cool cap.)"; @@ -740,7 +740,7 @@ namespace CostEstimateManager { } if (coilFound) { state.dataCostEstimateManager->CostLineItem(Item).Qty = - state.dataCoilCooingDX->coilCoolingDXs[thisCoil].performance.normalMode.ratedGrossTotalCap / 1000.0; + state.dataCoilCoolingDX->coilCoolingDXs[thisCoil].performance.normalMode.ratedGrossTotalCap / 1000.0; state.dataCostEstimateManager->CostLineItem(Item).Units = "kW (tot cool cap.)"; state.dataCostEstimateManager->CostLineItem(Item).ValuePer = state.dataCostEstimateManager->CostLineItem(Item).PerKiloWattCap; state.dataCostEstimateManager->CostLineItem(Item).LineSubTotal = @@ -750,7 +750,7 @@ namespace CostEstimateManager { if (state.dataCostEstimateManager->CostLineItem(Item).PerEach > 0.0) { if (WildcardObjNames) - state.dataCostEstimateManager->CostLineItem(Item).Qty = double(state.dataCoilCooingDX->coilCoolingDXs.size()); + state.dataCostEstimateManager->CostLineItem(Item).Qty = double(state.dataCoilCoolingDX->coilCoolingDXs.size()); if (coilFound) state.dataCostEstimateManager->CostLineItem(Item).Qty = 1.0; state.dataCostEstimateManager->CostLineItem(Item).ValuePer = state.dataCostEstimateManager->CostLineItem(Item).PerEach; state.dataCostEstimateManager->CostLineItem(Item).LineSubTotal = @@ -761,7 +761,7 @@ namespace CostEstimateManager { if (state.dataCostEstimateManager->CostLineItem(Item).PerKWCapPerCOP > 0.0) { if (WildcardObjNames) { Real64 Qty(0.0); - for (auto const &e : state.dataCoilCooingDX->coilCoolingDXs) { + for (auto const &e : state.dataCoilCoolingDX->coilCoolingDXs) { auto const &maxSpeed = e.performance.normalMode.speeds.back(); Real64 COP = maxSpeed.original_input_specs.gross_rated_cooling_COP; Qty += COP * e.performance.normalMode.ratedGrossTotalCap; @@ -773,10 +773,10 @@ namespace CostEstimateManager { state.dataCostEstimateManager->CostLineItem(Item).Qty * state.dataCostEstimateManager->CostLineItem(Item).ValuePer; } if (coilFound) { - auto const &maxSpeed = state.dataCoilCooingDX->coilCoolingDXs[thisCoil].performance.normalMode.speeds.back(); + auto const &maxSpeed = state.dataCoilCoolingDX->coilCoolingDXs[thisCoil].performance.normalMode.speeds.back(); Real64 COP = maxSpeed.original_input_specs.gross_rated_cooling_COP; state.dataCostEstimateManager->CostLineItem(Item).Qty = - COP * state.dataCoilCooingDX->coilCoolingDXs[thisCoil].performance.normalMode.ratedGrossTotalCap / 1000.0; + COP * state.dataCoilCoolingDX->coilCoolingDXs[thisCoil].performance.normalMode.ratedGrossTotalCap / 1000.0; state.dataCostEstimateManager->CostLineItem(Item).Units = "kW*COP (total, rated) "; state.dataCostEstimateManager->CostLineItem(Item).ValuePer = state.dataCostEstimateManager->CostLineItem(Item).PerKWCapPerCOP; state.dataCostEstimateManager->CostLineItem(Item).LineSubTotal = diff --git a/src/EnergyPlus/DXCoils.cc b/src/EnergyPlus/DXCoils.cc index 05dab5bf21a..85b05b3d9da 100644 --- a/src/EnergyPlus/DXCoils.cc +++ b/src/EnergyPlus/DXCoils.cc @@ -9785,7 +9785,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state, // Default to cycling fan, cycling compressor // Also return this result for stage 2 operation of multimode coil // Cycling fan typically provides full outlet conditions. When RH control is used, account for additional - // heating run time by using cooing/heating ratio the same as constant fan (otherwise PLRRatio = 1). + // heating run time by using cooling/heating ratio the same as constant fan (otherwise PLRRatio = 1). OutletAirEnthalpy = FullLoadOutAirEnth * DXcoolToHeatPLRRatio + InletAirEnthalpy * (1.0 - DXcoolToHeatPLRRatio); OutletAirHumRat = FullLoadOutAirHumRat * DXcoolToHeatPLRRatio + InletAirHumRat * (1.0 - DXcoolToHeatPLRRatio); OutletAirTemp = FullLoadOutAirTemp * DXcoolToHeatPLRRatio + InletAirDryBulbTemp * (1.0 - DXcoolToHeatPLRRatio); diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc b/src/EnergyPlus/Data/EnergyPlusData.cc index b5f6169043f..f2b59fbcd09 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.cc +++ b/src/EnergyPlus/Data/EnergyPlusData.cc @@ -78,7 +78,7 @@ EnergyPlusData::EnergyPlusData() this->dataChillerIndirectAbsorption = std::make_unique(); this->dataChillerReformulatedEIR = std::make_unique(); this->dataChillerElectricASHRAE205 = std::make_unique(); - this->dataCoilCooingDX = std::make_unique(); + this->dataCoilCoolingDX = std::make_unique(); this->dataCondenserLoopTowers = std::make_unique(); this->dataConstruction = std::make_unique(); this->dataContaminantBalance = std::make_unique(); @@ -334,7 +334,7 @@ void EnergyPlusData::clear_state() this->dataChillerIndirectAbsorption->clear_state(); this->dataChillerReformulatedEIR->clear_state(); this->dataChillerElectricASHRAE205->clear_state(); - this->dataCoilCooingDX->clear_state(); + this->dataCoilCoolingDX->clear_state(); this->dataCondenserLoopTowers->clear_state(); this->dataConstruction->clear_state(); this->dataContaminantBalance->clear_state(); @@ -606,7 +606,7 @@ void EnergyPlusData::init_state(EnergyPlusData &state) this->dataChillerIndirectAbsorption->init_state(state); this->dataChillerReformulatedEIR->init_state(state); this->dataChillerElectricASHRAE205->init_state(state); - this->dataCoilCooingDX->init_state(state); + this->dataCoilCoolingDX->init_state(state); this->dataCondenserLoopTowers->init_state(state); this->dataConstruction->init_state(state); this->dataContaminantBalance->init_state(state); diff --git a/src/EnergyPlus/Data/EnergyPlusData.hh b/src/EnergyPlus/Data/EnergyPlusData.hh index 4b4279f9213..38de2a97017 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.hh +++ b/src/EnergyPlus/Data/EnergyPlusData.hh @@ -338,7 +338,7 @@ struct EnergyPlusData : BaseGlobalStruct std::unique_ptr dataChillerIndirectAbsorption; std::unique_ptr dataChillerReformulatedEIR; std::unique_ptr dataChillerElectricASHRAE205; - std::unique_ptr dataCoilCooingDX; + std::unique_ptr dataCoilCoolingDX; std::unique_ptr dataCondenserLoopTowers; std::unique_ptr dataConstruction; std::unique_ptr dataContaminantBalance; diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc index b901a205b13..4cad380d2db 100644 --- a/src/EnergyPlus/Furnaces.cc +++ b/src/EnergyPlus/Furnaces.cc @@ -1826,7 +1826,7 @@ namespace Furnaces { errFlag = true; ErrorsFound = true; } - auto const &newCoil = state.dataCoilCooingDX->coilCoolingDXs[childCCIndex]; + auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex]; thisFurnace.CondenserNodeNum = newCoil.condInletNodeIndex; @@ -5834,7 +5834,7 @@ namespace Furnaces { if (childCCIndex < 0) { ShowContinueError(state, "Occurs in sizing HeatExchangerAssistedCoolingCoil."); } - auto &newCoil = state.dataCoilCooingDX->coilCoolingDXs[childCCIndex]; + auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex]; newCoil.size(state); } HVACHXAssistedCoolingCoil::SimHXAssistedCoolingCoil( @@ -10865,7 +10865,7 @@ namespace Furnaces { errFlag = true; ErrorsFound = true; } - auto const &newCoil = state.dataCoilCooingDX->coilCoolingDXs[childCCIndex_DX]; + 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; diff --git a/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc b/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc index 16a310c32ef..fe61af6a082 100644 --- a/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc +++ b/src/EnergyPlus/HVACHXAssistedCoolingCoil.cc @@ -323,7 +323,7 @@ namespace HVACHXAssistedCoolingCoil { ErrorsFound = true; } - thisHXCoil.DXCoilNumOfSpeeds = state.dataCoilCooingDX->coilCoolingDXs[coolingCoilIndex_temp].performance.normalMode.speeds.size(); + thisHXCoil.DXCoilNumOfSpeeds = state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex_temp].performance.normalMode.speeds.size(); if (thisHXCoil.DXCoilNumOfSpeeds < 1) { CoolingCoilErrFlag = true; } @@ -389,7 +389,7 @@ namespace HVACHXAssistedCoolingCoil { } if (Util::SameString(thisHXCoil.CoolingCoilType, "Coil:Cooling:DX")) { - CoolingCoilInletNodeNum = state.dataCoilCooingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].evapInletNodeIndex; + CoolingCoilInletNodeNum = state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].evapInletNodeIndex; if (SupplyAirOutletNode != CoolingCoilInletNodeNum) { ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name)); ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object."); @@ -406,7 +406,7 @@ namespace HVACHXAssistedCoolingCoil { ErrorsFound = true; } - CoolingCoilOutletNodeNum = state.dataCoilCooingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].evapOutletNodeIndex; + CoolingCoilOutletNodeNum = state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].evapOutletNodeIndex; if (SecondaryAirInletNode != CoolingCoilOutletNodeNum) { ShowSevereError(state, format("{}{}=\"{}\"", RoutineName, CurrentModuleObject, thisHXCoil.Name)); ShowContinueError(state, "Node names are inconsistent in heat exchanger and cooling coil object."); @@ -836,9 +836,9 @@ namespace HVACHXAssistedCoolingCoil { if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_Cooling) { // - // state.dataCoilCooingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex] + // state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex] // .outletAirDryBulbTemp = 0.0; - // state.dataCoilCooingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].outletAirHumRat = + // state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].outletAirHumRat = // 0.0; } else if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) { state.dataDXCoils->DXCoilFullLoadOutAirTemp(thisHXCoil.CoolingCoilIndex) = 0.0; @@ -930,14 +930,14 @@ namespace HVACHXAssistedCoolingCoil { int coolingCoilIndex = thisHXCoil.CoolingCoilIndex; - int mSingleMode = state.dataCoilCooingDX->coilCoolingDXs[coolingCoilIndex].getNumModes(); + int mSingleMode = state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex].getNumModes(); bool singleMode = (mSingleMode == 1); - Real64 mCoolingSpeedNum = state.dataCoilCooingDX->coilCoolingDXs[coolingCoilIndex] + Real64 mCoolingSpeedNum = state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex] .performance.normalMode.speeds.size(); // used the same for the original variable speed coil HVAC::CoilMode coilMode = HVAC::CoilMode::Normal; - if (state.dataCoilCooingDX->coilCoolingDXs[coolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[coolingCoilIndex].SubcoolReheatFlag) { coilMode = HVAC::CoilMode::SubcoolReheat; } else if (DehumidificationMode == HVAC::CoilMode::Enhanced) { coilMode = HVAC::CoilMode::Enhanced; @@ -960,13 +960,13 @@ namespace HVACHXAssistedCoolingCoil { CoilPLR = PartLoadRatio * ((compressorOp == HVAC::CompressorOp::On) ? 1.0 : 0.0); } - state.dataCoilCooingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].simulate(state, - coilMode, // partially implemented for HXAssistedCoil - CoilPLR, // PartLoadRatio, - mCoolingSpeedNum, - mCoolingSpeedRatio, - fanOp, - singleMode); // + state.dataCoilCoolingDX->coilCoolingDXs[thisHXCoil.CoolingCoilIndex].simulate(state, + coilMode, // partially implemented for HXAssistedCoil + CoilPLR, // PartLoadRatio, + mCoolingSpeedNum, + mCoolingSpeedRatio, + fanOp, + singleMode); // } else if (thisHXCoil.CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed) { DXCoils::SimDXCoil(state, @@ -1171,7 +1171,7 @@ namespace HVACHXAssistedCoolingCoil { if (state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilType_Num == HVAC::CoilDX_Cooling) { int coolingCoilDXIndex = state.dataHVACAssistedCC->HXAssistedCoil(WhichCoil).CoolingCoilIndex; - CoilCapacity = state.dataCoilCooingDX->coilCoolingDXs[coolingCoilDXIndex].performance.normalMode.ratedGrossTotalCap; + 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, diff --git a/src/EnergyPlus/HVACManager.cc b/src/EnergyPlus/HVACManager.cc index f65ce5b40b5..a26a5d9e13b 100644 --- a/src/EnergyPlus/HVACManager.cc +++ b/src/EnergyPlus/HVACManager.cc @@ -1717,7 +1717,7 @@ void SimHVAC(EnergyPlusData &state) state.dataHVACGlobal->DoSetPointTest = false; } - if (state.dataCoilCooingDX->stillNeedToReportStandardRatings) { + if (state.dataCoilCoolingDX->stillNeedToReportStandardRatings) { if (!state.dataGlobal->WarmupFlag) { CoilCoolingDX::reportAllStandardRatings(state); } diff --git a/src/EnergyPlus/HVACUnitaryBypassVAV.cc b/src/EnergyPlus/HVACUnitaryBypassVAV.cc index 3fed480323c..65452f31af6 100644 --- a/src/EnergyPlus/HVACUnitaryBypassVAV.cc +++ b/src/EnergyPlus/HVACUnitaryBypassVAV.cc @@ -109,7 +109,7 @@ namespace HVACUnitaryBypassVAV { // METHODOLOGY EMPLOYED: // Units are modeled as a collection of components: outside air mixer, - // supply air fan, DX cooing coil, DX/gas/elec heating coil, and variable volume boxes. + // supply air fan, DX cooling coil, DX/gas/elec heating coil, and variable volume boxes. // Control is accomplished by calculating the load in all zones to determine a mode of operation. // The system will either cool, heat, or operate based on fan mode selection. @@ -751,7 +751,7 @@ namespace HVACUnitaryBypassVAV { ShowContinueError(state, format("...occurs in {} \"{}\"", thisCBVAV.UnitType, thisCBVAV.Name)); ErrorsFound = true; } else { - auto const &newCoil = state.dataCoilCooingDX->coilCoolingDXs[thisCBVAV.DXCoolCoilIndexNum]; + auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[thisCBVAV.DXCoolCoilIndexNum]; thisCBVAV.DXCoilInletNode = newCoil.evapInletNodeIndex; thisCBVAV.DXCoilOutletNode = newCoil.evapOutletNodeIndex; thisCBVAV.CondenserNodeNum = newCoil.condInletNodeIndex; diff --git a/src/EnergyPlus/HeatRecovery.cc b/src/EnergyPlus/HeatRecovery.cc index 96b293112cd..c95221fd58d 100644 --- a/src/EnergyPlus/HeatRecovery.cc +++ b/src/EnergyPlus/HeatRecovery.cc @@ -1502,8 +1502,8 @@ namespace HeatRecovery { state.dataHeatRecovery->FullLoadOutAirHumRat = state.dataVariableSpeedCoils->VarSpeedCoil(CompanionCoilIndex).OutletAirHumRat; } else if (CompanionCoilType_Num == HVAC::CoilDX_Cooling) { // Use the new coil option: - state.dataHeatRecovery->FullLoadOutAirTemp = state.dataCoilCooingDX->coilCoolingDXs[CompanionCoilIndex].outletAirDryBulbTemp; - state.dataHeatRecovery->FullLoadOutAirHumRat = state.dataCoilCooingDX->coilCoolingDXs[CompanionCoilIndex].outletAirHumRat; + state.dataHeatRecovery->FullLoadOutAirTemp = state.dataCoilCoolingDX->coilCoolingDXs[CompanionCoilIndex].outletAirDryBulbTemp; + state.dataHeatRecovery->FullLoadOutAirHumRat = state.dataCoilCoolingDX->coilCoolingDXs[CompanionCoilIndex].outletAirHumRat; } else { // } @@ -2631,7 +2631,7 @@ namespace HeatRecovery { } else if (CompanionCoilType > 0 && CompanionCoilIndex > -1) { if (CompanionCoilType == HVAC::CoilDX_Cooling) { - HXPartLoadRatio = state.dataCoilCooingDX->coilCoolingDXs[CompanionCoilIndex].partLoadRatioReport; + HXPartLoadRatio = state.dataCoilCoolingDX->coilCoolingDXs[CompanionCoilIndex].partLoadRatioReport; } else if (CompanionCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { HXPartLoadRatio = state.dataVariableSpeedCoils->VarSpeedCoil(CompanionCoilIndex).PartLoadRatio; } else { diff --git a/src/EnergyPlus/HeatingCoils.cc b/src/EnergyPlus/HeatingCoils.cc index 6b8a613eefd..155284e1d99 100644 --- a/src/EnergyPlus/HeatingCoils.cc +++ b/src/EnergyPlus/HeatingCoils.cc @@ -1247,7 +1247,7 @@ namespace HeatingCoils { state.dataHeatingCoils->InputErrorsFound = true; } DataHeatBalance::HeatReclaimDataBase &HeatReclaim = - state.dataCoilCooingDX->coilCoolingDXs[heatingCoil.ReclaimHeatingSourceIndexNum].reclaimHeat; + 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); @@ -1588,7 +1588,7 @@ namespace HeatingCoils { } case HeatObjTypes::COIL_COOLING_DX_NEW: DataHeatBalance::HeatReclaimDataBase &HeatReclaim = - state.dataCoilCooingDX->coilCoolingDXs[heatingCoil.ReclaimHeatingSourceIndexNum].reclaimHeat; + 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); @@ -2699,7 +2699,7 @@ namespace HeatingCoils { case HeatObjTypes::COIL_COOLING_DX_NEW: // get RTF and NominalCapacity from Coil:CoolingDX { - auto const &thisCoolingCoil = state.dataCoilCooingDX->coilCoolingDXs[SourceID]; + auto const &thisCoolingCoil = state.dataCoilCoolingDX->coilCoolingDXs[SourceID]; heatingCoil.RTF = thisCoolingCoil.runTimeFraction; heatingCoil.NominalCapacity = thisCoolingCoil.reclaimHeat.AvailCapacity * Effic - thisCoolingCoil.reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal; diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index 908f8733fe7..07e4c38fb3a 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -1512,7 +1512,7 @@ namespace UnitarySystems { SizingMethod = HVAC::CoolingCapacitySizing; if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) { state.dataSize->DataTotCapCurveIndex = - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getOpModeCapFTIndex(HVAC::CoilMode::Normal); + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getOpModeCapFTIndex(HVAC::CoilMode::Normal); state.dataSize->DataIsDXCoil = true; } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_CoolingSingleSpeed || this->m_CoolingCoilType_Num == HVAC::CoilDX_MultiSpeedCooling || @@ -1554,7 +1554,7 @@ namespace UnitarySystems { switch (this->m_CoolingCoilType_Num) { case HVAC::CoilDX_Cooling: { state.dataSize->DataTotCapCurveIndex = - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getOpModeCapFTIndex(HVAC::CoilMode::Normal); + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getOpModeCapFTIndex(HVAC::CoilMode::Normal); state.dataSize->DataIsDXCoil = true; } break; case HVAC::CoilDX_CoolingSingleSpeed: @@ -2083,7 +2083,7 @@ namespace UnitarySystems { NoLoadCoolingAirFlowRateRatio = 1.0 / state.dataDXCoils->DXCoil(this->m_CoolingCoilIndex).NumOfSpeeds; } } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) { - NoLoadCoolingAirFlowRateRatio = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex] + NoLoadCoolingAirFlowRateRatio = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex] .performance.normalMode.speeds[0] .original_input_specs.evaporator_air_flow_fraction; } @@ -2500,7 +2500,7 @@ namespace UnitarySystems { ShowFatalError(state, "No cooling coil = Coil:Cooling:DX found."); ErrFound = true; } - auto &newCoil = state.dataCoilCooingDX->coilCoolingDXs[childCCIndex]; + auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex]; 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); @@ -2591,7 +2591,7 @@ namespace UnitarySystems { } // mine capacity from Coil:Cooling:DX object - auto &newCoil = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex]; + auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex]; // 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)); @@ -3590,7 +3590,7 @@ namespace UnitarySystems { ShowFatalError(state, format("Occurs in {} = {}", cCurrentModuleObject, thisObjectName)); } else { // set variable speed coil flag as necessary - auto &newCoil = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex]; + auto &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex]; this->m_NumOfSpeedCooling = (int)newCoil.performance.normalMode.speeds.size(); if (this->m_NumOfSpeedCooling > 1) { if (newCoil.performance.capControlMethod == CoilCoolingDXCurveFitPerformance::CapControlMethod::DISCRETE) { @@ -4533,7 +4533,7 @@ namespace UnitarySystems { // mine data from coil object // TODO: Need to check for autosize on these I guess - auto &newCoil = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex]; + 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; @@ -4661,7 +4661,7 @@ namespace UnitarySystems { errorsFound = true; } - auto const &newCoil = state.dataCoilCooingDX->coilCoolingDXs[childCCIndex]; + auto const &newCoil = state.dataCoilCoolingDX->coilCoolingDXs[childCCIndex]; this->m_CoolingCoilAvailSchPtr = newCoil.availScheduleIndex; // thisSys.m_DesignCoolingCapacity = newCoil.performance.normalMode.ratedGrossTotalCap; @@ -5192,7 +5192,7 @@ namespace UnitarySystems { this->m_CoolingCoilType_Num == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) { DXCoils::SetDXCoilTypeData(state, this->m_CoolingCoilName); } else if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling) { - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].setToHundredPercentDOAS(); + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].setToHundredPercentDOAS(); } } // DOAS DX Cooling Coil Leaving Minimum Air Temperature @@ -6054,13 +6054,14 @@ namespace UnitarySystems { } if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && this->m_DehumidControlType_Num == DehumCtrlType::Multimode) { - int numCoolingCoilModes = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getNumModes(); + int numCoolingCoilModes = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].getNumModes(); if (numCoolingCoilModes == 1) { ShowSevereError(state, format("{} = {}", cCurrentModuleObject, thisObjectName)); 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.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].name)); + state, + format("Cooling coil named: {} has only one mode", state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].name)); ShowFatalError(state, "Multimode cooling coil error causes program termination"); } } else if (this->m_CoolingCoilType_Num != HVAC::CoilDX_CoolingHXAssisted && @@ -8052,7 +8053,7 @@ namespace UnitarySystems { if (ZoneLoad < 0.0 && state.dataUnitarySystems->MoistureLoad <= 0.0 && (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag)) { + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag)) { this->LoadSHR = ZoneLoad / (ZoneLoad + state.dataUnitarySystems->MoistureLoad * Psychrometrics::PsyHgAirFnWTdb( @@ -8954,9 +8955,9 @@ namespace UnitarySystems { Real64 SensOutput; Real64 LatOutput; if (this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { if (state.dataUnitarySystems->CoolingLoad && this->LoadSHR > 0.0) { - int CoilInletNode = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].evapInletNodeIndex; + int CoilInletNode = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].evapInletNodeIndex; this->CoilSHR = 0.0; Real64 LowSpeedCoilSen; Real64 LowSpeedCoilLat; @@ -9120,7 +9121,7 @@ namespace UnitarySystems { PartLoadRatio = CoolPLR; } else if (state.dataGlobal->DoCoilDirectSolutions && state.dataUnitarySystems->CoolingLoad && this->m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && this->m_NumOfSpeedCooling == 1 && - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { HeatPLR = 0.0; this->calcUnitarySystemToLoad(state, AirLoopNum, @@ -11519,13 +11520,13 @@ namespace UnitarySystems { } HVAC::CoilMode coilMode = HVAC::CoilMode::Normal; - if (state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { coilMode = HVAC::CoilMode::SubcoolReheat; } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) { coilMode = HVAC::CoilMode::Enhanced; } - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( state, coilMode, CoilPLR, this->m_CoolingSpeedNum, this->m_CoolingSpeedRatio, this->m_FanOpMode, singleMode, this->CoilSHR); if (this->m_CoolingSpeedNum > 1) { @@ -12309,13 +12310,13 @@ namespace UnitarySystems { } } else { HVAC::CoilMode coilMode = HVAC::CoilMode::Normal; - if (state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].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.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( state, coilMode, PartLoadFrac, this->m_CoolingSpeedNum, this->m_CoolingSpeedRatio, this->m_FanOpMode, singleMode); } @@ -12370,13 +12371,13 @@ namespace UnitarySystems { state.dataHVACGlobal->MSHPMassFlowRateLow = this->m_DesignMassFlowRate; state.dataHVACGlobal->MSHPMassFlowRateHigh = this->m_DesignMassFlowRate; HVAC::CoilMode coilMode = HVAC::CoilMode::Normal; - if (state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].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.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( state, coilMode, PartLoadFrac, 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 @@ -12572,7 +12573,7 @@ namespace UnitarySystems { } else if (CoilType_Num == HVAC::CoilDX_Cooling) { // CoilCoolingDX HVAC::CoilMode coilMode = HVAC::CoilMode::Normal; - if (state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { coilMode = HVAC::CoilMode::SubcoolReheat; } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) { coilMode = HVAC::CoilMode::Enhanced; @@ -12581,7 +12582,7 @@ namespace UnitarySystems { bool const singleMode = (this->m_SingleMode == 1); for (int speedNum = 1; speedNum <= this->m_NumOfSpeedCooling; speedNum++) { this->m_CoolingSpeedNum = speedNum; - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( state, coilMode, PartLoadFrac, this->m_CoolingSpeedNum, this->m_CoolingSpeedRatio, this->m_FanOpMode, singleMode); if (speedNum == this->m_NumOfSpeedCooling) { FullLoadHumRatOut = state.dataLoopNodes->Node(OutletNode).HumRat; @@ -12992,14 +12993,14 @@ namespace UnitarySystems { Real64 CoolingSpeedRatio = this->m_CoolingSpeedRatio; bool const singleMode = this->m_SingleMode; if (CoolingSpeedNum == 1) { - state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].simulate( state, DehumidMode, PartLoadRatio, CoolingSpeedNum, CoolingSpeedRatio, fanOp, singleMode); } else { - state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].simulate( state, DehumidMode, CoolingSpeedRatio, CoolingSpeedNum, PartLoadRatio, fanOp, singleMode); } Real64 outletCondition = - state.dataLoopNodes->Node(state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].evapOutletNodeIndex).Temp; + state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].evapOutletNodeIndex).Temp; return DesOutTemp - outletCondition; }; @@ -13198,7 +13199,7 @@ namespace UnitarySystems { } else if (CoilType_Num == HVAC::CoilDX_Cooling) { // CoilCoolingDX HVAC::CoilMode coilMode = HVAC::CoilMode::Enhanced; - if (state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { coilMode = HVAC::CoilMode::SubcoolReheat; } if (this->m_CoolingSpeedNum == 0) this->m_CoolingSpeedNum = 1; @@ -13206,7 +13207,7 @@ namespace UnitarySystems { PartLoadFrac = 1.0; for (int speedNum = this->m_CoolingSpeedNum; speedNum <= this->m_NumOfSpeedCooling; speedNum++) { this->m_CoolingSpeedNum = speedNum; - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( state, coilMode, PartLoadFrac, 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; @@ -13222,14 +13223,14 @@ namespace UnitarySystems { Real64 CoolingSpeedRatio = 1.0; bool const singleMode = false; if (CoolingSpeedNum == 1) { - state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].simulate( state, HVAC::CoilMode::Enhanced, PartLoadFrac, CoolingSpeedNum, CoolingSpeedRatio, fanOp, singleMode); } else { - state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].simulate( state, HVAC::CoilMode::Enhanced, CoolingSpeedRatio, CoolingSpeedNum, PartLoadFrac, fanOp, singleMode); } Real64 outletCondition = - state.dataLoopNodes->Node(state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].evapOutletNodeIndex).Temp; + state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].evapOutletNodeIndex).Temp; return DesOutTemp - outletCondition; }; @@ -13644,7 +13645,7 @@ namespace UnitarySystems { PartLoadFrac = 1.0; for (int speedNum = this->m_CoolingSpeedNum; speedNum <= this->m_NumOfSpeedCooling; speedNum++) { this->m_CoolingSpeedNum = speedNum; - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( state, coilMode, PartLoadFrac, 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; @@ -13663,14 +13664,14 @@ namespace UnitarySystems { Real64 CoolingSpeedRatio = 1.0; bool const singleMode = false; if (CoolingSpeedNum == 1) { - state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].simulate( state, HVAC::CoilMode::Normal, PartLoadFrac, CoolingSpeedNum, CoolingSpeedRatio, fanOp, singleMode); } else { - state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].simulate( state, HVAC::CoilMode::Normal, CoolingSpeedRatio, CoolingSpeedNum, PartLoadFrac, fanOp, singleMode); } Real64 outletCondition = - state.dataLoopNodes->Node(state.dataCoilCooingDX->coilCoolingDXs[CoilIndex].evapOutletNodeIndex).HumRat; + state.dataLoopNodes->Node(state.dataCoilCoolingDX->coilCoolingDXs[CoilIndex].evapOutletNodeIndex).HumRat; return DesOutHumRat - outletCondition; }; @@ -15062,13 +15063,13 @@ namespace UnitarySystems { } bool const singleMode = (this->m_SingleMode == 1); HVAC::CoilMode coilMode = HVAC::CoilMode::Normal; - if (state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { coilMode = HVAC::CoilMode::SubcoolReheat; } else if (this->m_DehumidificationMode == HVAC::CoilMode::Enhanced) { coilMode = HVAC::CoilMode::Enhanced; } - state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( + state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].simulate( state, coilMode, CycRatio, this->m_CoolingSpeedNum, SpeedRatio, this->m_FanOpMode, singleMode, this->CoilSHR); } else if (CoilTypeNum == HVAC::Coil_CoolingAirToAirVariableSpeed) { @@ -15474,10 +15475,10 @@ namespace UnitarySystems { } elecCoolingPower = state.dataHVACGlobal->DXElecCoolingPower; } else { - if (state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { + if (state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].SubcoolReheatFlag) { if (state.dataUnitarySystems->CoolingLoad && this->LoadSHR == 0.0) { this->LoadSHR = 1.0; - this->CoilSHR = state.dataCoilCooingDX->coilCoolingDXs[this->m_CoolingCoilIndex].performance.NormalSHR; + this->CoilSHR = state.dataCoilCoolingDX->coilCoolingDXs[this->m_CoolingCoilIndex].performance.NormalSHR; } } Real64 CompPartLoadFrac = this->m_CompPartLoadRatio; @@ -16951,7 +16952,7 @@ namespace UnitarySystems { if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilIndex >= 0) { if (state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilType_Num == HVAC::CoilDX_Cooling && - state.dataCoilCooingDX->coilCoolingDXs[state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilIndex] + state.dataCoilCoolingDX->coilCoolingDXs[state.dataUnitarySystems->unitarySys[sysNum].m_CoolingCoilIndex] .SubcoolReheatFlag) { SetupOutputVariable(state, "Unitary System Zone Load Sensible Heat Ratio", diff --git a/src/EnergyPlus/WaterThermalTanks.cc b/src/EnergyPlus/WaterThermalTanks.cc index aa06680c9c0..e4be1028de6 100644 --- a/src/EnergyPlus/WaterThermalTanks.cc +++ b/src/EnergyPlus/WaterThermalTanks.cc @@ -995,7 +995,7 @@ bool getDesuperHtrInput(EnergyPlusData &state) ErrorsFound = true; } else { DataHeatBalance::HeatReclaimDataBase &HeatReclaim = - state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat; + state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat; if (!allocated(HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat)) { HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat.allocate(state.dataWaterThermalTanks->numWaterHeaterDesuperheater); for (auto &num : HeatReclaim.WaterHeatingDesuperheaterReclaimedHeat) @@ -8611,9 +8611,9 @@ void WaterThermalTankData::CalcDesuperheaterWaterHeater(EnergyPlusData &state, b DesupHtr.DXSysPLR = state.dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(SourceID).PartLoadRatio; } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CoilCoolingDX) { AverageWasteHeat = - state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.AvailCapacity - - state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.HVACDesuperheaterReclaimedHeatTotal; - DesupHtr.DXSysPLR = state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].partLoadRatioReport; + state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.AvailCapacity - + state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.HVACDesuperheaterReclaimedHeatTotal; + DesupHtr.DXSysPLR = state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].partLoadRatioReport; } } else { AverageWasteHeat = 0.0; @@ -8953,13 +8953,13 @@ void WaterThermalTankData::CalcDesuperheaterWaterHeater(EnergyPlusData &state, b for (auto const &num : state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeat) state.dataHeatBal->HeatReclaimSimple_WAHPCoil(SourceID).WaterHeatingDesuperheaterReclaimedHeatTotal += num; } else if (DesupHtr.ReclaimHeatingSource == ReclaimHeatObjectType::CoilCoolingDX) { - state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat( + state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat( DesuperheaterNum) = DesupHtr.HeaterRate; - state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal = + state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal = 0.0; for (auto const &num : - state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat) - state.dataCoilCooingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum] + state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum].reclaimHeat.WaterHeatingDesuperheaterReclaimedHeat) + state.dataCoilCoolingDX->coilCoolingDXs[DesupHtr.ReclaimHeatingSourceIndexNum] .reclaimHeat.WaterHeatingDesuperheaterReclaimedHeatTotal += num; } } diff --git a/tst/EnergyPlus/unit/Coils/CoilCoolingDX.unit.cc b/tst/EnergyPlus/unit/Coils/CoilCoolingDX.unit.cc index ce3f783a433..afbbd79922c 100644 --- a/tst/EnergyPlus/unit/Coils/CoilCoolingDX.unit.cc +++ b/tst/EnergyPlus/unit/Coils/CoilCoolingDX.unit.cc @@ -72,7 +72,7 @@ TEST_F(CoilCoolingDXTest, CoilCoolingDXInput) std::string idf_objects = this->getCoilObjectString("coolingCoil", false, 2); EXPECT_TRUE(process_idf(idf_objects, false)); int coilIndex = CoilCoolingDX::factory(*state, "coolingCoil"); - auto const &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto const &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); EXPECT_EQ("COOLINGCOIL", thisCoil.name); EXPECT_EQ("PERFORMANCEOBJECTNAME", thisCoil.performance.name); } @@ -145,7 +145,7 @@ TEST_F(CoilCoolingDXTest, CoilCoolingDXAlternateModePerformance) " ,,,,,,,,,,,;"}); EXPECT_TRUE(process_idf(idf_objects, false)); int coilIndex = CoilCoolingDX::factory(*state, "Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // fix the inlet conditions auto &evapInletNode = state->dataLoopNodes->Node(thisCoil.evapInletNodeIndex); @@ -281,7 +281,7 @@ TEST_F(CoilCoolingDXTest, CoilCoolingDXAlternateModePerformanceHitsSaturation) " ,,,,,,,,,,,;"}); EXPECT_TRUE(process_idf(idf_objects, false)); int coilIndex = CoilCoolingDX::factory(*state, "Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // fix the inlet conditions auto &evapInletNode = state->dataLoopNodes->Node(thisCoil.evapInletNodeIndex); @@ -669,7 +669,7 @@ TEST_F(EnergyPlusFixture, DISABLED_CoilDXCoolingVsMultiSpeed_CycFanCycCoil) }); EXPECT_TRUE(process_idf(idf_objects, false)); int coilIndex = CoilCoolingDX::factory(*state, "Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // fix the inlet conditions auto &evapInletNode = state->dataLoopNodes->Node(thisCoil.evapInletNodeIndex); @@ -1086,7 +1086,7 @@ TEST_F(EnergyPlusFixture, DISABLED_CoilDXCoolingVsMultiSpeed_ContFanCycCoil) }); EXPECT_TRUE(process_idf(idf_objects, false)); int coilIndex = CoilCoolingDX::factory(*state, "Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // fix the inlet conditions auto &evapInletNode = state->dataLoopNodes->Node(thisCoil.evapInletNodeIndex); @@ -1807,7 +1807,7 @@ TEST_F(CoilCoolingDXTest, CoilCoolingDX_LowerSpeedFlowSizingTest) ASSERT_TRUE(process_idf(idf_objects)); int coilIndex = CoilCoolingDX::factory(*state, "DX Cooling Coil"); - auto &this_dx_clg_coil = state->dataCoilCooingDX->coilCoolingDXs[coilIndex]; + auto &this_dx_clg_coil = state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]; // check dx cooling coil inputs EXPECT_EQ(this_dx_clg_coil.name, "DX COOLING COIL"); diff --git a/tst/EnergyPlus/unit/Coils/CoilCoolingDXCurveFitOperatingMode.unit.cc b/tst/EnergyPlus/unit/Coils/CoilCoolingDXCurveFitOperatingMode.unit.cc index 80c22d588ec..65b3d2098ce 100644 --- a/tst/EnergyPlus/unit/Coils/CoilCoolingDXCurveFitOperatingMode.unit.cc +++ b/tst/EnergyPlus/unit/Coils/CoilCoolingDXCurveFitOperatingMode.unit.cc @@ -261,7 +261,7 @@ TEST_F(CoilCoolingDXTest, CoilCoolingDXCurveFitCrankcaseHeaterCurve) idf_objects += this->getSpeedObjectString("Coil Cooling DX Curve Fit Speed 1"); EXPECT_TRUE(process_idf(idf_objects, false)); int coilIndex = CoilCoolingDX::factory(*state, "Coil Cooling DX 1"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); EXPECT_EQ("COIL COOLING DX 1", thisCoil.name); EXPECT_EQ("COIL COOLING DX CURVE FIT PERFORMANCE 1", thisCoil.performance.name); EXPECT_EQ("HEATERCAPCURVE", Curve::GetCurveName(*state, thisCoil.performance.crankcaseHeaterCapacityCurveIndex)); diff --git a/tst/EnergyPlus/unit/Furnaces.unit.cc b/tst/EnergyPlus/unit/Furnaces.unit.cc index e77f261fa94..d2f63df8a68 100644 --- a/tst/EnergyPlus/unit/Furnaces.unit.cc +++ b/tst/EnergyPlus/unit/Furnaces.unit.cc @@ -1234,10 +1234,10 @@ TEST_F(EnergyPlusFixture, Furnaces_SetMinOATCompressor) state->dataHVACAssistedCC->HXAssistedCoil(1).CoolingCoilType = "COIL:COOLING:DX"; state->dataHVACAssistedCC->HXAssistedCoil(1).CoolingCoilName = "Dummy_Name"; - state->dataCoilCooingDX->coilCoolingDXGetInputFlag = false; + state->dataCoilCoolingDX->coilCoolingDXGetInputFlag = false; CoilCoolingDX thisCoil; thisCoil.name = "Dummy_Name"; - state->dataCoilCooingDX->coilCoolingDXs.push_back(thisCoil); + state->dataCoilCoolingDX->coilCoolingDXs.push_back(thisCoil); int FurnaceNum = 1; std::string cCurModObj = "Furnace_Test"; diff --git a/tst/EnergyPlus/unit/StandardRatings.unit.cc b/tst/EnergyPlus/unit/StandardRatings.unit.cc index ffc7729e4ad..6e4666c4a1b 100644 --- a/tst/EnergyPlus/unit/StandardRatings.unit.cc +++ b/tst/EnergyPlus/unit/StandardRatings.unit.cc @@ -11724,7 +11724,7 @@ TEST_F(EnergyPlusFixture, CurveFit_02_Speed_15000W_alternateMode_SEER2_2023_Valu ASSERT_TRUE(process_idf(idf_objects)); int coilIndex = CoilCoolingDX::factory(*state, "DX Cooling Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // size it thisCoil.size(*state); @@ -12045,7 +12045,7 @@ TEST_F(EnergyPlusFixture, CurveFit_03_Speed_5000W_SEER2_2023_ValueTest) ASSERT_TRUE(process_idf(idf_objects)); int coilIndex = CoilCoolingDX::factory(*state, "Sys 2 Furnace DX Cool Cooling Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // size it thisCoil.size(*state); @@ -12348,7 +12348,7 @@ TEST_F(EnergyPlusFixture, CurveFit_02_Speed_30000W_alternateMode_IEER_2022_Value ASSERT_TRUE(process_idf(idf_objects)); int coilIndex = CoilCoolingDX::factory(*state, "DX Cooling Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // size it thisCoil.size(*state); @@ -12667,7 +12667,7 @@ TEST_F(EnergyPlusFixture, CurveFit_03_Speed_20000W_IEER_2022_ValueTest) ASSERT_TRUE(process_idf(idf_objects)); int coilIndex = CoilCoolingDX::factory(*state, "Sys 2 Furnace DX Cool Cooling Coil"); - auto &thisCoil(state->dataCoilCooingDX->coilCoolingDXs[coilIndex]); + auto &thisCoil(state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]); // size it thisCoil.size(*state); diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index 891ab7c3cda..c148265f686 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -16323,7 +16323,7 @@ Dimensionless; !- Output Unit Type ZoneEquipFlag, SenOutput, LatOutput); - auto &coilCoolingDX = state->dataCoilCooingDX->coilCoolingDXs[0]; + auto &coilCoolingDX = state->dataCoilCoolingDX->coilCoolingDXs[0]; EXPECT_EQ(coilCoolingDX.performance.OperatingMode, 3); EXPECT_EQ(coilCoolingDX.performance.ModeRatio, 1.0); EXPECT_NEAR(thisSys->CoilSHR, thisSys->LoadSHR, 0.001); @@ -20583,7 +20583,7 @@ Curve:Biquadratic, EIRFT, 1, 0, 0, 0, 0, 0, 0, 100, 0, 100, , , Temperature, Tem UnitarySystems::UnitarySys::factory(*state, HVAC::UnitarySysType::Unitary_AnyCoilType, UnitarySysName, zoneEquipment, 0); UnitarySystems::UnitarySys *thisSys = &state->dataUnitarySystems->unitarySys[0]; int coilIndex = CoilCoolingDX::factory(*state, "DX ClgCoil"); - auto &this_dx_clg_coil = state->dataCoilCooingDX->coilCoolingDXs[coilIndex]; + auto &this_dx_clg_coil = state->dataCoilCoolingDX->coilCoolingDXs[coilIndex]; state->dataZoneEquip->ZoneEquipInputsFilled = true; thisSys->getUnitarySystemInputData(*state, UnitarySysName, zoneEquipment, 0, ErrorsFound); EXPECT_FALSE(ErrorsFound);